From 234840303b5764565f5be8719d4e5a7a99531312 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 09:26:38 +1000 Subject: [PATCH 01/19] hard to describe --- src/main/java/graphql/GraphQL.java | 23 +- .../AbstractAsyncExecutionStrategy.java | 4 +- src/main/java/graphql/execution/Async.java | 24 +- .../execution/AsyncExecutionStrategy.java | 2 +- .../AsyncSerialExecutionStrategy.java | 2 +- src/main/java/graphql/execution/CF.java | 3620 +++++++++++++++++ .../graphql/execution/ExecutionStrategy.java | 4 +- .../instrumentation/Instrumentation.java | 3 +- .../NoOpPreparsedDocumentProvider.java | 3 +- src/test/groovy/graphql/GraphQLTest.groovy | 34 + 10 files changed, 3689 insertions(+), 30 deletions(-) create mode 100644 src/main/java/graphql/execution/CF.java diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index 096a4f7e26..acfb7adc3a 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -4,6 +4,7 @@ import graphql.execution.Async; import graphql.execution.AsyncExecutionStrategy; import graphql.execution.AsyncSerialExecutionStrategy; +import graphql.execution.CF; import graphql.execution.DataFetcherExceptionHandler; import graphql.execution.Execution; import graphql.execution.ExecutionId; @@ -356,7 +357,8 @@ public ExecutionResult execute(UnaryOperator builderFunc */ public ExecutionResult execute(ExecutionInput executionInput) { try { - return executeAsync(executionInput).join(); + CompletableFuture executionResultCompletableFuture = executeAsync(executionInput); + return executionResultCompletableFuture.join(); } catch (CompletionException e) { if (e.getCause() instanceof RuntimeException) { throw (RuntimeException) e.getCause(); @@ -415,7 +417,8 @@ public CompletableFuture executeAsync(ExecutionInput executionI ExecutionInput executionInputWithId = ensureInputHasId(executionInput); CompletableFuture instrumentationStateCF = instrumentation.createStateAsync(new InstrumentationCreateStateParameters(this.graphQLSchema, executionInputWithId)); - return Async.orNullCompletedFuture(instrumentationStateCF).thenCompose(instrumentationState -> { + CF rootCF = Async.orNullCompletedFuture(instrumentationStateCF); + CF cf = rootCF.thenCompose(instrumentationState -> { try { InstrumentationExecutionParameters inputInstrumentationParameters = new InstrumentationExecutionParameters(executionInputWithId, this.graphQLSchema); ExecutionInput instrumentedExecutionInput = instrumentation.instrumentExecutionInput(executionInputWithId, inputInstrumentationParameters, instrumentationState); @@ -426,26 +429,28 @@ public CompletableFuture executeAsync(ExecutionInput executionI GraphQLSchema graphQLSchema = instrumentation.instrumentSchema(this.graphQLSchema, instrumentationParameters, instrumentationState); - CompletableFuture executionResult = parseValidateAndExecute(instrumentedExecutionInput, graphQLSchema, instrumentationState); + CF executionResult = parseValidateAndExecute(instrumentedExecutionInput, graphQLSchema, instrumentationState); // // finish up instrumentation executionResult = executionResult.whenComplete(completeInstrumentationCtxCF(executionInstrumentation)); // // allow instrumentation to tweak the result - executionResult = executionResult.thenCompose(result -> instrumentation.instrumentExecutionResult(result, instrumentationParameters, instrumentationState)); + executionResult = executionResult.thenCompose(result -> CF.wrap(instrumentation.instrumentExecutionResult(result, instrumentationParameters, instrumentationState))); return executionResult; } catch (AbortExecutionException abortException) { return handleAbortException(executionInput, instrumentationState, abortException); } }); + rootCF.complete(null); + return cf; } private CompletableFuture handleAbortException(ExecutionInput executionInput, InstrumentationState instrumentationState, AbortExecutionException abortException) { - CompletableFuture executionResult = CompletableFuture.completedFuture(abortException.toExecutionResult()); + CF executionResult = CF.completedFuture(abortException.toExecutionResult()); InstrumentationExecutionParameters instrumentationParameters = new InstrumentationExecutionParameters(executionInput, this.graphQLSchema); // // allow instrumentation to tweak the result - executionResult = executionResult.thenCompose(result -> instrumentation.instrumentExecutionResult(result, instrumentationParameters, instrumentationState)); + executionResult = executionResult.thenCompose(result -> CF.wrap(instrumentation.instrumentExecutionResult(result, instrumentationParameters, instrumentationState))); return executionResult; } @@ -460,17 +465,17 @@ private ExecutionInput ensureInputHasId(ExecutionInput executionInput) { } - private CompletableFuture parseValidateAndExecute(ExecutionInput executionInput, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState) { + private CF parseValidateAndExecute(ExecutionInput executionInput, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState) { AtomicReference executionInputRef = new AtomicReference<>(executionInput); Function computeFunction = transformedInput -> { // if they change the original query in the pre-parser, then we want to see it downstream from then on executionInputRef.set(transformedInput); return parseAndValidate(executionInputRef, graphQLSchema, instrumentationState); }; - CompletableFuture preparsedDoc = preparsedDocumentProvider.getDocumentAsync(executionInput, computeFunction); + CF preparsedDoc = CF.wrap(preparsedDocumentProvider.getDocumentAsync(executionInput, computeFunction)); return preparsedDoc.thenCompose(preparsedDocumentEntry -> { if (preparsedDocumentEntry.hasErrors()) { - return CompletableFuture.completedFuture(new ExecutionResultImpl(preparsedDocumentEntry.getErrors())); + return CF.completedFuture(new ExecutionResultImpl(preparsedDocumentEntry.getErrors())); } try { return execute(executionInputRef.get(), preparsedDocumentEntry.getDocument(), graphQLSchema, instrumentationState); diff --git a/src/main/java/graphql/execution/AbstractAsyncExecutionStrategy.java b/src/main/java/graphql/execution/AbstractAsyncExecutionStrategy.java index 863e0d6fad..15268d4ae5 100644 --- a/src/main/java/graphql/execution/AbstractAsyncExecutionStrategy.java +++ b/src/main/java/graphql/execution/AbstractAsyncExecutionStrategy.java @@ -5,10 +5,8 @@ import graphql.ExecutionResultImpl; import graphql.PublicSpi; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import java.util.concurrent.CompletableFuture; import java.util.function.BiConsumer; @@ -22,7 +20,7 @@ public AbstractAsyncExecutionStrategy(DataFetcherExceptionHandler dataFetcherExc super(dataFetcherExceptionHandler); } - protected BiConsumer, Throwable> handleResults(ExecutionContext executionContext, List fieldNames, CompletableFuture overallResult) { + protected BiConsumer, Throwable> handleResults(ExecutionContext executionContext, List fieldNames, CF overallResult) { return (List results, Throwable exception) -> { if (exception != null) { handleNonNullException(executionContext, overallResult, exception); diff --git a/src/main/java/graphql/execution/Async.java b/src/main/java/graphql/execution/Async.java index aefe805951..f28b048edd 100644 --- a/src/main/java/graphql/execution/Async.java +++ b/src/main/java/graphql/execution/Async.java @@ -108,7 +108,7 @@ public Object awaitPolymorphic() { } // implementation details: infer the type of Completable> from a singleton empty - private static final CompletableFuture> EMPTY = CompletableFuture.completedFuture(Collections.emptyList()); + private static final CompletableFuture> EMPTY = CF.completedFuture(Collections.emptyList()); @SuppressWarnings("unchecked") private static CompletableFuture typedEmpty() { @@ -143,7 +143,7 @@ public CompletableFuture> await() { return cf.thenApply(Collections::singletonList); } //noinspection unchecked - return CompletableFuture.completedFuture(Collections.singletonList((T) value)); + return CF.completedFuture(Collections.singletonList((T) value)); } @Override @@ -194,12 +194,12 @@ public void addObject(Object object) { public CompletableFuture> await() { commonSizeAssert(); - CompletableFuture> overallResult = new CompletableFuture<>(); + CF> overallResult = new CF<>(); if (cfCount == 0) { overallResult.complete(materialisedList(array)); } else { - CompletableFuture[] cfsArr = copyOnlyCFsToArray(); - CompletableFuture.allOf(cfsArr) + CF[] cfsArr = copyOnlyCFsToArray(); + CF.allOf(cfsArr) .whenComplete((ignored, exception) -> { if (exception != null) { overallResult.completeExceptionally(exception); @@ -231,16 +231,16 @@ public CompletableFuture> await() { @SuppressWarnings("unchecked") @NonNull - private CompletableFuture[] copyOnlyCFsToArray() { + private CF[] copyOnlyCFsToArray() { if (cfCount == array.length) { // if it's all CFs - make a type safe copy via C code - return Arrays.copyOf(array, array.length, CompletableFuture[].class); + return Arrays.copyOf(array, array.length, CF[].class); } else { int i = 0; - CompletableFuture[] dest = new CompletableFuture[cfCount]; + CF[] dest = new CF[cfCount]; for (Object o : array) { - if (o instanceof CompletableFuture) { - dest[i] = (CompletableFuture) o; + if (o instanceof CF) { + dest[i] = (CF) o; i++; } } @@ -405,7 +405,7 @@ public static CompletableFuture exceptionallyCompletedFuture(Throwable ex * * @return the completableFuture if it's not null or one that always resoles to null */ - public static @NonNull CompletableFuture orNullCompletedFuture(@Nullable CompletableFuture completableFuture) { - return completableFuture != null ? completableFuture : CompletableFuture.completedFuture(null); + public static @NonNull CF orNullCompletedFuture(@Nullable CompletableFuture completableFuture) { + return completableFuture != null ? CF.wrap(completableFuture) : new CF<>();//CF.completedFuture(null); } } diff --git a/src/main/java/graphql/execution/AsyncExecutionStrategy.java b/src/main/java/graphql/execution/AsyncExecutionStrategy.java index bbd4a9cf68..3e815e85bb 100644 --- a/src/main/java/graphql/execution/AsyncExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncExecutionStrategy.java @@ -56,7 +56,7 @@ public CompletableFuture execute(ExecutionContext executionCont DeferredExecutionSupport deferredExecutionSupport = createDeferredExecutionSupport(executionContext, parameters); Async.CombinedBuilder futures = getAsyncFieldValueInfo(executionContext, parameters, deferredExecutionSupport); - CompletableFuture overallResult = new CompletableFuture<>(); + CF overallResult = new CF<>(); executionStrategyCtx.onDispatched(); futures.await().whenComplete((completeValueInfos, throwable) -> { diff --git a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java index fb871712da..ba0796b03e 100644 --- a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java @@ -58,7 +58,7 @@ public CompletableFuture execute(ExecutionContext executionCont return resolveSerialField(executionContext, dataLoaderDispatcherStrategy, newParameters); }); - CompletableFuture overallResult = new CompletableFuture<>(); + CF overallResult = new CF<>(); executionStrategyCtx.onDispatched(); resultsFuture.whenComplete(handleResults(executionContext, fieldNames, overallResult)); diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java new file mode 100644 index 0000000000..0965d17963 --- /dev/null +++ b/src/main/java/graphql/execution/CF.java @@ -0,0 +1,3620 @@ +package graphql.execution; +/* Original source from https://gee.cs.oswego.edu/dl/jsr166/src/jdk8/java/util/concurrent/CF.java + * + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.lang.invoke.MethodHandles; +import java.lang.invoke.VarHandle; +import java.util.List; +import java.util.Set; +import java.util.concurrent.CancellationException; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executor; +import java.util.concurrent.ForkJoinPool; +import java.util.concurrent.ForkJoinTask; +import java.util.concurrent.Future; +import java.util.concurrent.FutureTask; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.ScheduledThreadPoolExecutor; +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.locks.LockSupport; +import java.util.function.BiConsumer; +import java.util.function.BiFunction; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; + +/** + * A {@link Future} that may be explicitly completed (setting its + * value and status), and may be used as a {@link CompletionStage}, + * supporting dependent functions and actions that trigger upon its + * completion. + * + *

When two or more threads attempt to + * {@link #complete complete}, + * {@link #completeExceptionally completeExceptionally}, or + * {@link #cancel cancel} + * a CF, only one of them succeeds. + * + *

In addition to these and related methods for directly + * manipulating status and results, CF implements + * interface {@link CompletionStage} with the following policies:

    + * + *
  • Actions supplied for dependent completions of + * non-async methods may be performed by the thread that + * completes the current CF, or by any other caller of + * a completion method. + * + *
  • All async methods without an explicit Executor + * argument are performed using the {@link ForkJoinPool#commonPool()} + * (unless it does not support a parallelism level of at least two, in + * which case, a new Thread is created to run each task). This may be + * overridden for non-static methods in subclasses by defining method + * {@link #defaultExecutor()}. To simplify monitoring, debugging, + * and tracking, all generated asynchronous tasks are instances of the + * marker interface {@link AsynchronousCompletionTask}. Operations + * with time-delays can use adapter methods defined in this class, for + * example: {@code supplyAsync(supplier, delayedExecutor(timeout, + * timeUnit))}. To support methods with delays and timeouts, this + * class maintains at most one daemon thread for triggering and + * cancelling actions, not for running them. + * + *
  • All CompletionStage methods are implemented independently of + * other public methods, so the behavior of one method is not impacted + * by overrides of others in subclasses. + * + *
  • All CompletionStage methods return CFs. To + * restrict usages to only those methods defined in interface + * CompletionStage, use method {@link #minimalCompletionStage}. Or to + * ensure only that clients do not themselves modify a future, use + * method {@link #copy}. + *
+ * + *

CF also implements {@link Future} with the following + * policies:

    + * + *
  • Since (unlike {@link FutureTask}) this class has no direct + * control over the computation that causes it to be completed, + * cancellation is treated as just another form of exceptional + * completion. Method {@link #cancel cancel} has the same effect as + * {@code completeExceptionally(new CancellationException())}. Method + * {@link #isCompletedExceptionally} can be used to determine if a + * CF completed in any exceptional fashion. + * + *
  • In case of exceptional completion with a CompletionException, + * methods {@link #get()} and {@link #get(long, TimeUnit)} throw an + * {@link ExecutionException} with the same cause as held in the + * corresponding CompletionException. To simplify usage in most + * contexts, this class also defines methods {@link #join()} and + * {@link #getNow} that instead throw the CompletionException directly + * in these cases. + *
+ * + *

Arguments used to pass a completion result (that is, for + * parameters of type {@code T}) for methods accepting them may be + * null, but passing a null value for any other parameter will result + * in a {@link NullPointerException} being thrown. + * + *

Subclasses of this class should normally override the "virtual + * constructor" method {@link #newIncompleteFuture}, which establishes + * the concrete type returned by CompletionStage methods. For example, + * here is a class that substitutes a different default Executor and + * disables the {@code obtrude} methods: + * + * 

 {@code
+ * class MyCF extends CF {
+ *   static final Executor myExecutor = ...;
+ *   public MyCF() { }
+ *   public  CF newIncompleteFuture() {
+ *     return new MyCF(); }
+ *   public Executor defaultExecutor() {
+ *     return myExecutor; }
+ *   public void obtrudeValue(T value) {
+ *     throw new UnsupportedOperationException(); }
+ *   public void obtrudeException(Throwable ex) {
+ *     throw new UnsupportedOperationException(); }
+ * }}
+ * + * @param The result type returned by this future's {@code join} + * and {@code get} methods + * + * @author Doug Lea + * @since 1.8 + */ +public class CF extends CompletableFuture { + private static final Logger log = LoggerFactory.getLogger(CF.class); + + /* + * Overview: + * + * A CF may have dependent completion actions, + * collected in a linked stack. It atomically completes by CASing + * a result field, and then pops off and runs those actions. This + * applies across normal vs exceptional outcomes, sync vs async + * actions, binary triggers, and various forms of completions. + * + * Non-nullness of volatile field "result" indicates done. It may + * be set directly if known to be thread-confined, else via CAS. + * An AltResult is used to box null as a result, as well as to + * hold exceptions. Using a single field makes completion simple + * to detect and trigger. Result encoding and decoding is + * straightforward but tedious and adds to the sprawl of trapping + * and associating exceptions with targets. Minor simplifications + * rely on (static) NIL (to box null results) being the only + * AltResult with a null exception field, so we don't usually need + * explicit comparisons. Even though some of the generics casts + * are unchecked (see SuppressWarnings annotations), they are + * placed to be appropriate even if checked. + * + * Dependent actions are represented by Completion objects linked + * as Treiber stacks headed by field "stack". There are Completion + * classes for each kind of action, grouped into: + * - single-input (UniCompletion), + * - two-input (BiCompletion), + * - projected (BiCompletions using exactly one of two inputs), + * - shared (CoCompletion, used by the second of two sources), + * - zero-input source actions, + * - Signallers that unblock waiters. + * Class Completion extends ForkJoinTask to enable async execution + * (adding no space overhead because we exploit its "tag" methods + * to maintain claims). It is also declared as Runnable to allow + * usage with arbitrary executors. + * + * Support for each kind of CompletionStage relies on a separate + * class, along with two CF methods: + * + * * A Completion class with name X corresponding to function, + * prefaced with "Uni", "Bi", or "Or". Each class contains + * fields for source(s), actions, and dependent. They are + * boringly similar, differing from others only with respect to + * underlying functional forms. We do this so that users don't + * encounter layers of adapters in common usages. + * + * * Boolean CF method x(...) (for example + * biApply) takes all of the arguments needed to check that an + * action is triggerable, and then either runs the action or + * arranges its async execution by executing its Completion + * argument, if present. The method returns true if known to be + * complete. + * + * * Completion method tryFire(int mode) invokes the associated x + * method with its held arguments, and on success cleans up. + * The mode argument allows tryFire to be called twice (SYNC, + * then ASYNC); the first to screen and trap exceptions while + * arranging to execute, and the second when called from a task. + * (A few classes are not used async so take slightly different + * forms.) The claim() callback suppresses function invocation + * if already claimed by another thread. + * + * * Some classes (for example UniApply) have separate handling + * code for when known to be thread-confined ("now" methods) and + * for when shared (in tryFire), for efficiency. + * + * * CF method xStage(...) is called from a public + * stage method of CF f. It screens user + * arguments and invokes and/or creates the stage object. If + * not async and already triggerable, the action is run + * immediately. Otherwise a Completion c is created, and + * submitted to the executor if triggerable, or pushed onto f's + * stack if not. Completion actions are started via c.tryFire. + * We recheck after pushing to a source future's stack to cover + * possible races if the source completes while pushing. + * Classes with two inputs (for example BiApply) deal with races + * across both while pushing actions. The second completion is + * a CoCompletion pointing to the first, shared so that at most + * one performs the action. The multiple-arity methods allOf + * does this pairwise to form trees of completions. Method + * anyOf is handled differently from allOf because completion of + * any source should trigger a cleanStack of other sources. + * Each AnyOf completion can reach others via a shared array. + * + * Note that the generic type parameters of methods vary according + * to whether "this" is a source, dependent, or completion. + * + * Method postComplete is called upon completion unless the target + * is guaranteed not to be observable (i.e., not yet returned or + * linked). Multiple threads can call postComplete, which + * atomically pops each dependent action, and tries to trigger it + * via method tryFire, in NESTED mode. Triggering can propagate + * recursively, so NESTED mode returns its completed dependent (if + * one exists) for further processing by its caller (see method + * postFire). + * + * Blocking methods get() and join() rely on Signaller Completions + * that wake up waiting threads. The mechanics are similar to + * Treiber stack wait-nodes used in FutureTask, Phaser, and + * SynchronousQueue. See their internal documentation for + * algorithmic details. + * + * Without precautions, CFs would be prone to + * garbage accumulation as chains of Completions build up, each + * pointing back to its sources. So we null out fields as soon as + * possible. The screening checks needed anyway harmlessly ignore + * null arguments that may have been obtained during races with + * threads nulling out fields. We also try to unlink non-isLive + * (fired or cancelled) Completions from stacks that might + * otherwise never be popped: Method cleanStack always unlinks non + * isLive completions from the head of stack; others may + * occasionally remain if racing with other cancellations or + * removals. + * + * Completion fields need not be declared as final or volatile + * because they are only visible to other threads upon safe + * publication. + */ + + volatile Object result; // Either the result or boxed AltResult + volatile Completion stack; // Top of Treiber stack of dependent actions + + + final boolean internalComplete(Object r) { // CAS from null to r + boolean result = RESULT.compareAndSet(this, null, r); + afterCompletedInternal(); + return result; + } + + final boolean casStack(Completion cmp, Completion val) { + return STACK.compareAndSet(this, cmp, val); + } + + /** + * Returns true if successfully pushed c onto stack. + */ + final boolean tryPushStack(Completion c) { + Completion h = stack; + lazySetNext(c, h); + boolean success = STACK.compareAndSet(this, h, c); + return success; + } + + /** + * Unconditionally pushes c onto stack, retrying if necessary. + */ + final void pushStack(Completion c) { + do { + } while (!tryPushStack(c)); + } + + /* ------------- Encoding and decoding outcomes -------------- */ + + static final class AltResult { // See above + final Throwable ex; // null only for NIL + + AltResult(Throwable x) { + this.ex = x; + } + } + + /** + * The encoding of the null value. + */ + static final AltResult NIL = new AltResult(null); + + /** + * Completes with the null value, unless already completed. + */ + final boolean completeNull() { + boolean result = RESULT.compareAndSet(this, null, NIL); + afterCompletedInternal(); + return result; + } + + /** + * Returns the encoding of the given non-exceptional value. + */ + final Object encodeValue(T t) { + return (t == null) ? NIL : t; + } + + /** + * Completes with a non-exceptional result, unless already completed. + */ + final boolean completeValue(T t) { + boolean result = RESULT.compareAndSet(this, null, (t == null) ? NIL : t); + afterCompletedInternal(); + return result; + } + + /** + * Returns the encoding of the given (non-null) exception as a + * wrapped CompletionException unless it is one already. + */ + static AltResult encodeThrowable(Throwable x) { + return new AltResult((x instanceof CompletionException) ? x : + new CompletionException(x)); + } + + /** + * Completes with an exceptional result, unless already completed. + */ + final boolean completeThrowable(Throwable x) { + boolean result = RESULT.compareAndSet(this, null, encodeThrowable(x)); + afterCompletedInternal(); + return result; + } + + /** + * Returns the encoding of the given (non-null) exception as a + * wrapped CompletionException unless it is one already. May + * return the given Object r (which must have been the result of a + * source future) if it is equivalent, i.e. if this is a simple + * relay of an existing CompletionException. + */ + static Object encodeThrowable(Throwable x, Object r) { + if (!(x instanceof CompletionException)) { + x = new CompletionException(x); + } else if (r instanceof AltResult && x == ((AltResult) r).ex) { + return r; + } + return new AltResult(x); + } + + /** + * Completes with the given (non-null) exceptional result as a + * wrapped CompletionException unless it is one already, unless + * already completed. May complete with the given Object r + * (which must have been the result of a source future) if it is + * equivalent, i.e. if this is a simple propagation of an + * existing CompletionException. + */ + final boolean completeThrowable(Throwable x, Object r) { + boolean result = RESULT.compareAndSet(this, null, encodeThrowable(x, r)); + afterCompletedInternal(); + return result; + } + + /** + * Returns the encoding of the given arguments: if the exception + * is non-null, encodes as AltResult. Otherwise uses the given + * value, boxed as NIL if null. + */ + Object encodeOutcome(T t, Throwable x) { + return (x == null) ? (t == null) ? NIL : t : encodeThrowable(x); + } + + /** + * Returns the encoding of a copied outcome; if exceptional, + * rewraps as a CompletionException, else returns argument. + */ + static Object encodeRelay(Object r) { + Throwable x; + if (r instanceof AltResult + && (x = ((AltResult) r).ex) != null + && !(x instanceof CompletionException)) { + r = new AltResult(new CompletionException(x)); + } + return r; + } + + /** + * Completes with r or a copy of r, unless already completed. + * If exceptional, r is first coerced to a CompletionException. + */ + final boolean completeRelay(Object r) { + boolean result = RESULT.compareAndSet(this, null, encodeRelay(r)); + afterCompletedInternal(); + return result; + } + + /** + * Reports result using Future.get conventions. + */ + private static Object reportGet(Object r) + throws InterruptedException, ExecutionException { + if (r == null) // by convention below, null means interrupted + { + throw new InterruptedException(); + } + if (r instanceof AltResult) { + Throwable x, cause; + if ((x = ((AltResult) r).ex) == null) { + return null; + } + if (x instanceof CancellationException) { + throw (CancellationException) x; + } + if ((x instanceof CompletionException) && + (cause = x.getCause()) != null) { + x = cause; + } + throw new ExecutionException(x); + } + return r; + } + + /** + * Decodes outcome to return result or throw unchecked exception. + */ + private static Object reportJoin(Object r) { + if (r instanceof AltResult) { + Throwable x; + if ((x = ((AltResult) r).ex) == null) { + return null; + } + if (x instanceof CancellationException) { + throw (CancellationException) x; + } + if (x instanceof CompletionException) { + throw (CompletionException) x; + } + throw new CompletionException(x); + } + return r; + } + + /* ------------- Async task preliminaries -------------- */ + + /** + * A marker interface identifying asynchronous tasks produced by + * {@code async} methods. This may be useful for monitoring, + * debugging, and tracking asynchronous activities. + * + * @since 1.8 + */ + public static interface AsynchronousCompletionTask { + } + + private static final boolean USE_COMMON_POOL = + (ForkJoinPool.getCommonPoolParallelism() > 1); + + /** + * Default executor -- ForkJoinPool.commonPool() unless it cannot + * support parallelism. + */ + private static final Executor ASYNC_POOL = USE_COMMON_POOL ? + ForkJoinPool.commonPool() : new ThreadPerTaskExecutor(); + + /** + * Fallback if ForkJoinPool.commonPool() cannot support parallelism + */ + static final class ThreadPerTaskExecutor implements Executor { + public void execute(Runnable r) { + new Thread(r).start(); + } + } + + /** + * Null-checks user executor argument, and translates uses of + * commonPool to ASYNC_POOL in case parallelism disabled. + */ + static Executor screenExecutor(Executor e) { + if (!USE_COMMON_POOL && e == ForkJoinPool.commonPool()) { + return ASYNC_POOL; + } + if (e == null) { + throw new NullPointerException(); + } + return e; + } + + // Modes for Completion.tryFire. Signedness matters. + static final int SYNC = 0; + static final int ASYNC = 1; + static final int NESTED = -1; + + /* ------------- Base Completion classes and operations -------------- */ + + @SuppressWarnings("serial") + abstract static class Completion extends ForkJoinTask + implements Runnable, AsynchronousCompletionTask { + volatile Completion next; // Treiber stack link + + /** + * Performs completion action if triggered, returning a + * dependent that may need propagation, if one exists. + * + * @param mode SYNC, ASYNC, or NESTED + */ + abstract CF tryFire(int mode); + + /** + * Returns true if possibly still triggerable. Used by cleanStack. + */ + abstract boolean isLive(); + + public final void run() { + tryFire(ASYNC); + } + + public final boolean exec() { + tryFire(ASYNC); + return false; + } + + public final Void getRawResult() { + return null; + } + + public final void setRawResult(Void v) { + } + } + + static void lazySetNext(Completion c, Completion next) { + NEXT.set(c, next); + } + + static boolean casNext(Completion c, Completion cmp, Completion val) { + return NEXT.compareAndSet(c, cmp, val); + } + + /** + * Pops and tries to trigger all reachable dependents. Call only + * when known to be done. + */ + final void postComplete() { + /* + * On each step, variable f holds current dependents to pop + * and run. It is extended along only one path at a time, + * pushing others to avoid unbounded recursion. + */ + CF f = this; + Completion h; + while ((h = f.stack) != null || + (f != this && (h = (f = this).stack) != null)) { + CF d; + Completion t; + if (f.casStack(h, t = h.next)) { + if (t != null) { + if (f != this) { + pushStack(h); + continue; + } + casNext(h, t, null); // try to detach + } + f = (d = h.tryFire(NESTED)) == null ? this : d; + } + } + } + + /** + * Traverses stack and unlinks one or more dead Completions, if found. + */ + final void cleanStack() { + Completion p = stack; + // ensure head of stack live + for (boolean unlinked = false; ; ) { + if (p == null) { + return; + } else if (p.isLive()) { + if (unlinked) { + return; + } else { + break; + } + } else if (casStack(p, (p = p.next))) { + unlinked = true; + } else { + p = stack; + } + } + // try to unlink first non-live + for (Completion q = p.next; q != null; ) { + Completion s = q.next; + if (q.isLive()) { + p = q; + q = s; + } else if (casNext(p, q, s)) { + break; + } else { + q = p.next; + } + } + } + + /* ------------- One-input Completions -------------- */ + + /** + * A Completion with a source, dependent, and executor. + */ + @SuppressWarnings("serial") + abstract static class UniCompletion extends Completion { + Executor executor; // executor to use (null if none) + CF dep; // the dependent to complete + CF src; // source for action + + UniCompletion(Executor executor, CF dep, + CF src) { + this.executor = executor; + this.dep = dep; + this.src = src; + } + + /** + * Returns true if action can be run. Call only when known to + * be triggerable. Uses FJ tag bit to ensure that only one + * thread claims ownership. If async, starts as task -- a + * later call to tryFire will run action. + */ + final boolean claim() { + Executor e = executor; + if (compareAndSetForkJoinTaskTag((short) 0, (short) 1)) { + if (e == null) { + return true; + } + executor = null; // disable + e.execute(this); + } + return false; + } + + final boolean isLive() { + return dep != null; + } + } + + /** + * Pushes the given completion unless it completes while trying. + * Caller should first check that result is null. + */ + final void unipush(Completion c) { + if (c != null) { + while (!tryPushStack(c)) { + if (result != null) { + lazySetNext(c, null); + break; + } + } + if (result != null) { + c.tryFire(SYNC); + } + } + } + + /** + * Post-processing by dependent after successful UniCompletion tryFire. + * Tries to clean stack of source a, and then either runs postComplete + * or returns this to caller, depending on mode. + */ + final CF postFire(CF a, int mode) { + if (a != null && a.stack != null) { + Object r; + if ((r = a.result) == null) { + a.cleanStack(); + } + if (mode >= 0 && (r != null || a.result != null)) { + a.postComplete(); + } + } + if (result != null && stack != null) { + if (mode < 0) { + return this; + } else { + postComplete(); + } + } + return null; + } + + @SuppressWarnings("serial") + static final class UniApply extends UniCompletion { + Function fn; + + UniApply(Executor executor, CF dep, + CF src, + Function fn) { + super(executor, dep, src); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + Object r; + Throwable x; + Function f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null) { + return null; + } + tryComplete: + if (d.result == null) { + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + d.completeThrowable(x, r); + break tryComplete; + } + r = null; + } + try { + if (mode <= 0 && !claim()) { + return null; + } else { + @SuppressWarnings("unchecked") T t = (T) r; + d.completeValue(f.apply(t)); + } + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + dep = null; + src = null; + fn = null; + return d.postFire(a, mode); + } + } + + private CF uniApplyStage( + Executor e, Function f) { + if (f == null) { + throw new NullPointerException(); + } + Object r; + if ((r = result) != null) { + return uniApplyNow(r, e, f); + } + CF d = newIncompleteFuture(); + unipush(new UniApply(e, d, this, f)); + return d; + } + + private CF uniApplyNow( + Object r, Executor e, Function f) { + Throwable x; + CF d = newIncompleteFuture(); + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + d.assignResult(encodeThrowable(x, r)); + return d; + } + r = null; + } + try { + if (e != null) { + e.execute(new UniApply(null, d, this, f)); + } else { + @SuppressWarnings("unchecked") T t = (T) r; + d.assignResult(d.encodeValue(f.apply(t))); + } + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + return d; + } + + @SuppressWarnings("serial") + static final class UniAccept extends UniCompletion { + Consumer fn; + + UniAccept(Executor executor, CF dep, + CF src, Consumer fn) { + super(executor, dep, src); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + Object r; + Throwable x; + Consumer f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null) { + return null; + } + tryComplete: + if (d.result == null) { + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + d.completeThrowable(x, r); + break tryComplete; + } + r = null; + } + try { + if (mode <= 0 && !claim()) { + return null; + } else { + @SuppressWarnings("unchecked") T t = (T) r; + f.accept(t); + d.completeNull(); + } + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + dep = null; + src = null; + fn = null; + return d.postFire(a, mode); + } + } + + private CF uniAcceptStage(Executor e, + Consumer f) { + if (f == null) { + throw new NullPointerException(); + } + Object r; + if ((r = result) != null) { + return uniAcceptNow(r, e, f); + } + CF d = newIncompleteFuture(); + unipush(new UniAccept(e, d, this, f)); + return d; + } + + private CF uniAcceptNow( + Object r, Executor e, Consumer f) { + Throwable x; + CF d = newIncompleteFuture(); + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + d.assignResult(encodeThrowable(x, r)); + return d; + } + r = null; + } + try { + if (e != null) { + e.execute(new UniAccept(null, d, this, f)); + } else { + @SuppressWarnings("unchecked") T t = (T) r; + f.accept(t); + d.assignResult(NIL); + } + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + return d; + } + + @SuppressWarnings("serial") + static final class UniRun extends UniCompletion { + Runnable fn; + + UniRun(Executor executor, CF dep, + CF src, Runnable fn) { + super(executor, dep, src); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + Object r; + Throwable x; + Runnable f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null) { + return null; + } + if (d.result == null) { + if (r instanceof AltResult && (x = ((AltResult) r).ex) != null) { + d.completeThrowable(x, r); + } else { + try { + if (mode <= 0 && !claim()) { + return null; + } else { + f.run(); + d.completeNull(); + } + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + } + dep = null; + src = null; + fn = null; + return d.postFire(a, mode); + } + } + + private CF uniRunStage(Executor e, Runnable f) { + if (f == null) { + throw new NullPointerException(); + } + Object r; + if ((r = result) != null) { + return uniRunNow(r, e, f); + } + CF d = newIncompleteFuture(); + unipush(new UniRun(e, d, this, f)); + return d; + } + + private CF uniRunNow(Object r, Executor e, Runnable f) { + Throwable x; + CF d = newIncompleteFuture(); + if (r instanceof AltResult && (x = ((AltResult) r).ex) != null) { + d.assignResult(encodeThrowable(x, r)); + } else { + try { + if (e != null) { + e.execute(new UniRun(null, d, this, f)); + } else { + f.run(); + d.assignResult(NIL); + } + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + @SuppressWarnings("serial") + static final class UniWhenComplete extends UniCompletion { + BiConsumer fn; + + UniWhenComplete(Executor executor, CF dep, + CF src, + BiConsumer fn) { + super(executor, dep, src); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + Object r; + BiConsumer f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null + || !d.uniWhenComplete(r, f, mode > 0 ? null : this)) { + return null; + } + dep = null; + src = null; + fn = null; + return d.postFire(a, mode); + } + } + + final boolean uniWhenComplete(Object r, + BiConsumer f, + UniWhenComplete c) { + T t; + Throwable x = null; + if (result == null) { + try { + if (c != null && !c.claim()) { + return false; + } + if (r instanceof AltResult) { + x = ((AltResult) r).ex; + t = null; + } else { + @SuppressWarnings("unchecked") T tr = (T) r; + t = tr; + } + f.accept(t, x); + if (x == null) { + internalComplete(r); + return true; + } + } catch (Throwable ex) { + if (x == null) { + x = ex; + } else if (x != ex) { + x.addSuppressed(ex); + } + } + completeThrowable(x, r); + } + return true; + } + + private CF uniWhenCompleteStage( + Executor e, BiConsumer f) { + if (f == null) { + throw new NullPointerException(); + } + CF d = newIncompleteFuture(); + Object r; + if ((r = result) == null) { + unipush(new UniWhenComplete(e, d, this, f)); + } else if (e == null) { + d.uniWhenComplete(r, f, null); + } else { + try { + e.execute(new UniWhenComplete(null, d, this, f)); + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + @SuppressWarnings("serial") + static final class UniHandle extends UniCompletion { + BiFunction fn; + + UniHandle(Executor executor, CF dep, + CF src, + BiFunction fn) { + super(executor, dep, src); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + Object r; + BiFunction f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null + || !d.uniHandle(r, f, mode > 0 ? null : this)) { + return null; + } + dep = null; + src = null; + fn = null; + return d.postFire(a, mode); + } + } + + final boolean uniHandle(Object r, + BiFunction f, + UniHandle c) { + S s; + Throwable x; + if (result == null) { + try { + if (c != null && !c.claim()) { + return false; + } + if (r instanceof AltResult) { + x = ((AltResult) r).ex; + s = null; + } else { + x = null; + @SuppressWarnings("unchecked") S ss = (S) r; + s = ss; + } + completeValue(f.apply(s, x)); + } catch (Throwable ex) { + completeThrowable(ex); + } + } + return true; + } + + private CF uniHandleStage( + Executor e, BiFunction f) { + if (f == null) { + throw new NullPointerException(); + } + CF d = newIncompleteFuture(); + Object r; + if ((r = result) == null) { + unipush(new UniHandle(e, d, this, f)); + } else if (e == null) { + d.uniHandle(r, f, null); + } else { + try { + e.execute(new UniHandle(null, d, this, f)); + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + @SuppressWarnings("serial") + static final class UniExceptionally extends UniCompletion { + Function fn; + + UniExceptionally(Executor executor, + CF dep, CF src, + Function fn) { + super(executor, dep, src); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + Object r; + Function f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null + || !d.uniExceptionally(r, f, mode > 0 ? null : this)) { + return null; + } + dep = null; + src = null; + fn = null; + return d.postFire(a, mode); + } + } + + final boolean uniExceptionally(Object r, + Function f, + UniExceptionally c) { + Throwable x; + if (result == null) { + try { + if (c != null && !c.claim()) { + return false; + } + if (r instanceof AltResult && (x = ((AltResult) r).ex) != null) { + completeValue(f.apply(x)); + } else { + internalComplete(r); + } + } catch (Throwable ex) { + completeThrowable(ex); + } + } + return true; + } + + private CF uniExceptionallyStage( + Executor e, Function f) { + if (f == null) { + throw new NullPointerException(); + } + CF d = newIncompleteFuture(); + Object r; + if ((r = result) == null) { + unipush(new UniExceptionally(e, d, this, f)); + } else if (e == null) { + d.uniExceptionally(r, f, null); + } else { + try { + e.execute(new UniExceptionally(null, d, this, f)); + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + @SuppressWarnings("serial") + static final class UniComposeExceptionally extends UniCompletion { + Function> fn; + + UniComposeExceptionally(Executor executor, CF dep, + CF src, + Function> fn) { + super(executor, dep, src); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + Function> f; + Object r; + Throwable x; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null) { + return null; + } + if (d.result == null) { + if ((r instanceof AltResult) && + (x = ((AltResult) r).ex) != null) { + try { + if (mode <= 0 && !claim()) { + return null; + } + CF g = (CF) f.apply(x).toCompletableFuture(); + if ((r = g.result) != null) { + d.completeRelay(r); + } else { + g.unipush(new UniRelay(d, g)); + if (d.result == null) { + return null; + } + } + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } else { + d.internalComplete(r); + } + } + dep = null; + src = null; + fn = null; + return d.postFire(a, mode); + } + } + + private CF uniComposeExceptionallyStage( + Executor e, Function> f) { + if (f == null) { + throw new NullPointerException(); + } + CF d = newIncompleteFuture(); + Object r, s; + Throwable x; + if ((r = result) == null) { + unipush(new UniComposeExceptionally(e, d, this, f)); + } else if (!(r instanceof AltResult) || (x = ((AltResult) r).ex) == null) { + d.internalComplete(r); + } else { + try { + if (e != null) { + e.execute(new UniComposeExceptionally(null, d, this, f)); + } else { + CF g = (CF) f.apply(x).toCompletableFuture(); + if ((s = g.result) != null) { + d.assignResult(encodeRelay(s)); + } else { + g.unipush(new UniRelay(d, g)); + } + } + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + @SuppressWarnings("serial") + static final class UniRelay extends UniCompletion { + UniRelay(CF dep, CF src) { + super(null, dep, src); + } + + final CF tryFire(int mode) { + CF d; + CF a; + Object r; + if ((d = dep) == null + || (a = src) == null || (r = a.result) == null) { + return null; + } + if (d.result == null) { + d.completeRelay(r); + } + src = null; + dep = null; + return d.postFire(a, mode); + } + } + + private static CF uniCopyStage( + CF src) { + Object r; + CF d = src.newIncompleteFuture(); + if ((r = src.result) != null) { + d.assignResult(encodeRelay(r)); + } else { + src.unipush(new UniRelay(d, src)); + } + return d; + } + + private MinimalStage uniAsMinimalStage() { + Object r; + if ((r = result) != null) { + return new MinimalStage(encodeRelay(r)); + } + MinimalStage d = new MinimalStage(); + unipush(new UniRelay(d, this)); + return d; + } + + @SuppressWarnings("serial") + static final class UniCompose extends UniCompletion { + Function> fn; + + UniCompose(Executor executor, CF dep, + CF src, + Function> fn) { + super(executor, dep, src); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + Function> f; + Object r; + Throwable x; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null) { + return null; + } + tryComplete: + if (d.result == null) { + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + d.completeThrowable(x, r); + break tryComplete; + } + r = null; + } + try { + if (mode <= 0 && !claim()) { + return null; + } + @SuppressWarnings("unchecked") T t = (T) r; + CF g = (CF) f.apply(t).toCompletableFuture(); + if ((r = g.result) != null) { + d.completeRelay(r); + } else { + g.unipush(new UniRelay(d, g)); + if (d.result == null) { + return null; + } + } + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + dep = null; + src = null; + fn = null; + return d.postFire(a, mode); + } + } + + private CF uniComposeStage( + Executor e, Function> f) { + if (f == null) { + throw new NullPointerException(); + } + CF d = newIncompleteFuture(); + Object r, s; + Throwable x; + if ((r = result) == null) { + unipush(new UniCompose(e, d, this, f)); + } else if (e == null) { + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + d.assignResult(encodeThrowable(x, r)); + return d; + } + r = null; + } + try { + @SuppressWarnings("unchecked") T t = (T) r; + CF g = (CF) f.apply(t).toCompletableFuture(); + if ((s = g.result) != null) { + d.assignResult(encodeRelay(s)); + } else { + g.unipush(new UniRelay(d, g)); + } + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } else { + try { + e.execute(new UniCompose(null, d, this, f)); + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + /* ------------- Two-input Completions -------------- */ + + /** + * A Completion for an action with two sources + */ + @SuppressWarnings("serial") + abstract static class BiCompletion extends UniCompletion { + CF snd; // second source for action + + BiCompletion(Executor executor, CF dep, + CF src, CF snd) { + super(executor, dep, src); + this.snd = snd; + } + } + + /** + * A Completion delegating to a BiCompletion + */ + @SuppressWarnings("serial") + static final class CoCompletion extends Completion { + BiCompletion base; + + CoCompletion(BiCompletion base) { + this.base = base; + } + + final CF tryFire(int mode) { + BiCompletion c; + CF d; + if ((c = base) == null || (d = c.tryFire(mode)) == null) { + return null; + } + base = null; // detach + return d; + } + + final boolean isLive() { + BiCompletion c; + return (c = base) != null + // && c.isLive() + && c.dep != null; + } + } + + /** + * Pushes completion to this and b unless both done. + * Caller should first check that either result or b.result is null. + */ + final void bipush(CF b, BiCompletion c) { + if (c != null) { + while (result == null) { + if (tryPushStack(c)) { + if (b.result == null) { + b.unipush(new CoCompletion(c)); + } else if (result != null) { + c.tryFire(SYNC); + } + return; + } + } + b.unipush(c); + } + } + + /** + * Post-processing after successful BiCompletion tryFire. + */ + final CF postFire(CF a, + CF b, int mode) { + if (b != null && b.stack != null) { // clean second source + Object r; + if ((r = b.result) == null) { + b.cleanStack(); + } + if (mode >= 0 && (r != null || b.result != null)) { + b.postComplete(); + } + } + return postFire(a, mode); + } + + @SuppressWarnings("serial") + static final class BiApply extends BiCompletion { + BiFunction fn; + + BiApply(Executor executor, CF dep, + CF src, CF snd, + BiFunction fn) { + super(executor, dep, src, snd); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + CF b; + Object r, s; + BiFunction f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null + || (b = snd) == null || (s = b.result) == null + || !d.biApply(r, s, f, mode > 0 ? null : this)) { + return null; + } + dep = null; + src = null; + snd = null; + fn = null; + return d.postFire(a, b, mode); + } + } + + final boolean biApply(Object r, Object s, + BiFunction f, + BiApply c) { + Throwable x; + tryComplete: + if (result == null) { + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + completeThrowable(x, r); + break tryComplete; + } + r = null; + } + if (s instanceof AltResult) { + if ((x = ((AltResult) s).ex) != null) { + completeThrowable(x, s); + break tryComplete; + } + s = null; + } + try { + if (c != null && !c.claim()) { + return false; + } + @SuppressWarnings("unchecked") R rr = (R) r; + @SuppressWarnings("unchecked") S ss = (S) s; + completeValue(f.apply(rr, ss)); + } catch (Throwable ex) { + completeThrowable(ex); + } + } + return true; + } + + private CF biApplyStage( + Executor e, CompletionStage o, + BiFunction f) { + CF b; + Object r, s; + if (f == null || (b = (CF) o.toCompletableFuture()) == null) { + throw new NullPointerException(); + } + CF d = newIncompleteFuture(); + if ((r = result) == null || (s = b.result) == null) { + bipush(b, new BiApply(e, d, this, b, f)); + } else if (e == null) { + d.biApply(r, s, f, null); + } else { + try { + e.execute(new BiApply(null, d, this, b, f)); + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + @SuppressWarnings("serial") + static final class BiAccept extends BiCompletion { + BiConsumer fn; + + BiAccept(Executor executor, CF dep, + CF src, CF snd, + BiConsumer fn) { + super(executor, dep, src, snd); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + CF b; + Object r, s; + BiConsumer f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null + || (b = snd) == null || (s = b.result) == null + || !d.biAccept(r, s, f, mode > 0 ? null : this)) { + return null; + } + dep = null; + src = null; + snd = null; + fn = null; + return d.postFire(a, b, mode); + } + } + + final boolean biAccept(Object r, Object s, + BiConsumer f, + BiAccept c) { + Throwable x; + tryComplete: + if (result == null) { + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + completeThrowable(x, r); + break tryComplete; + } + r = null; + } + if (s instanceof AltResult) { + if ((x = ((AltResult) s).ex) != null) { + completeThrowable(x, s); + break tryComplete; + } + s = null; + } + try { + if (c != null && !c.claim()) { + return false; + } + @SuppressWarnings("unchecked") R rr = (R) r; + @SuppressWarnings("unchecked") S ss = (S) s; + f.accept(rr, ss); + completeNull(); + } catch (Throwable ex) { + completeThrowable(ex); + } + } + return true; + } + + private CF biAcceptStage( + Executor e, CompletionStage o, + BiConsumer f) { + CF b; + Object r, s; + if (f == null || (b = (CF) o.toCompletableFuture()) == null) { + throw new NullPointerException(); + } + CF d = newIncompleteFuture(); + if ((r = result) == null || (s = b.result) == null) { + bipush(b, new BiAccept(e, d, this, b, f)); + } else if (e == null) { + d.biAccept(r, s, f, null); + } else { + try { + e.execute(new BiAccept(null, d, this, b, f)); + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + @SuppressWarnings("serial") + static final class BiRun extends BiCompletion { + Runnable fn; + + BiRun(Executor executor, CF dep, + CF src, CF snd, + Runnable fn) { + super(executor, dep, src, snd); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + CF b; + Object r, s; + Runnable f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (r = a.result) == null + || (b = snd) == null || (s = b.result) == null + || !d.biRun(r, s, f, mode > 0 ? null : this)) { + return null; + } + dep = null; + src = null; + snd = null; + fn = null; + return d.postFire(a, b, mode); + } + } + + final boolean biRun(Object r, Object s, Runnable f, BiRun c) { + Throwable x; + Object z; + if (result == null) { + if ((r instanceof AltResult + && (x = ((AltResult) (z = r)).ex) != null) || + (s instanceof AltResult + && (x = ((AltResult) (z = s)).ex) != null)) { + completeThrowable(x, z); + } else { + try { + if (c != null && !c.claim()) { + return false; + } + f.run(); + completeNull(); + } catch (Throwable ex) { + completeThrowable(ex); + } + } + } + return true; + } + + private CF biRunStage(Executor e, CompletionStage o, + Runnable f) { + CF b; + Object r, s; + if (f == null || (b = (CF) o.toCompletableFuture()) == null) { + throw new NullPointerException(); + } + CF d = newIncompleteFuture(); + if ((r = result) == null || (s = b.result) == null) { + bipush(b, new BiRun<>(e, d, this, b, f)); + } else if (e == null) { + d.biRun(r, s, f, null); + } else { + try { + e.execute(new BiRun<>(null, d, this, b, f)); + } catch (Throwable ex) { + d.assignResult(encodeThrowable(ex)); + } + } + return d; + } + + @SuppressWarnings("serial") + static final class BiRelay extends BiCompletion { // for And + BiRelay(CF dep, + CF src, CF snd) { + super(null, dep, src, snd); + } + + final CF tryFire(int mode) { + CF d; + CF a; + CF b; + Object r, s, z; + Throwable x; + if ((d = dep) == null + || (a = src) == null || (r = a.result) == null + || (b = snd) == null || (s = b.result) == null) { + return null; + } + if (d.result == null) { + if ((r instanceof AltResult + && (x = ((AltResult) (z = r)).ex) != null) || + (s instanceof AltResult + && (x = ((AltResult) (z = s)).ex) != null)) { + d.completeThrowable(x, z); + } else { + d.completeNull(); + } + } + src = null; + snd = null; + dep = null; + return d.postFire(a, b, mode); + } + } + + /** + * Recursively constructs a tree of completions. + */ + static CF andTree(CF[] cfs, + int lo, int hi) { + CF d = new CF<>(); + if (lo > hi) // empty + { + d.assignResult(NIL); + } else { + CF a, b; + Object r, s, z; + Throwable x; + int mid = (lo + hi) >>> 1; + if ((a = (lo == mid ? cfs[lo] : + andTree(cfs, lo, mid))) == null || + (b = (lo == hi ? a : (hi == mid + 1) ? cfs[hi] : + andTree(cfs, mid + 1, hi))) == null) { + throw new NullPointerException(); + } + if ((r = a.result) == null || (s = b.result) == null) { + a.bipush(b, new BiRelay<>(d, a, b)); + } else if ((r instanceof AltResult + && (x = ((AltResult) (z = r)).ex) != null) || + (s instanceof AltResult + && (x = ((AltResult) (z = s)).ex) != null)) { + d.assignResult(encodeThrowable(x, z)); + } else { + d.assignResult(NIL); + } + } + return d; + } + + /* ------------- Projected (Ored) BiCompletions -------------- */ + + /** + * Pushes completion to this and b unless either done. + * Caller should first check that result and b.result are both null. + */ + final void orpush(CF b, BiCompletion c) { + if (c != null) { + while (!tryPushStack(c)) { + if (result != null) { + lazySetNext(c, null); + break; + } + } + if (result != null) { + c.tryFire(SYNC); + } else { + b.unipush(new CoCompletion(c)); + } + } + } + + @SuppressWarnings("serial") + static final class OrApply extends BiCompletion { + Function fn; + + OrApply(Executor executor, CF dep, + CF src, CF snd, + Function fn) { + super(executor, dep, src, snd); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + CF b; + Object r; + Throwable x; + Function f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (b = snd) == null + || ((r = a.result) == null && (r = b.result) == null)) { + return null; + } + tryComplete: + if (d.result == null) { + try { + if (mode <= 0 && !claim()) { + return null; + } + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + d.completeThrowable(x, r); + break tryComplete; + } + r = null; + } + @SuppressWarnings("unchecked") T t = (T) r; + d.completeValue(f.apply(t)); + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + dep = null; + src = null; + snd = null; + fn = null; + return d.postFire(a, b, mode); + } + } + + private CF orApplyStage( + Executor e, CompletionStage o, Function f) { + CF b; + if (f == null || (b = (CF) o.toCompletableFuture()) == null) { + throw new NullPointerException(); + } + + Object r; + CF z; + if ((r = (z = this).result) != null || + (r = (z = b).result) != null) { + return z.uniApplyNow(r, e, f); + } + + CF d = newIncompleteFuture(); + orpush(b, new OrApply(e, d, this, b, f)); + return d; + } + + @SuppressWarnings("serial") + static final class OrAccept extends BiCompletion { + Consumer fn; + + OrAccept(Executor executor, CF dep, + CF src, CF snd, + Consumer fn) { + super(executor, dep, src, snd); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + CF b; + Object r; + Throwable x; + Consumer f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (b = snd) == null + || ((r = a.result) == null && (r = b.result) == null)) { + return null; + } + tryComplete: + if (d.result == null) { + try { + if (mode <= 0 && !claim()) { + return null; + } + if (r instanceof AltResult) { + if ((x = ((AltResult) r).ex) != null) { + d.completeThrowable(x, r); + break tryComplete; + } + r = null; + } + @SuppressWarnings("unchecked") T t = (T) r; + f.accept(t); + d.completeNull(); + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + dep = null; + src = null; + snd = null; + fn = null; + return d.postFire(a, b, mode); + } + } + + private CF orAcceptStage( + Executor e, CompletionStage o, Consumer f) { + CF b; + if (f == null || (b = (CF) o.toCompletableFuture()) == null) { + throw new NullPointerException(); + } + + Object r; + CF z; + if ((r = (z = this).result) != null || + (r = (z = b).result) != null) { + return z.uniAcceptNow(r, e, f); + } + + CF d = newIncompleteFuture(); + orpush(b, new OrAccept(e, d, this, b, f)); + return d; + } + + @SuppressWarnings("serial") + static final class OrRun extends BiCompletion { + Runnable fn; + + OrRun(Executor executor, CF dep, + CF src, CF snd, + Runnable fn) { + super(executor, dep, src, snd); + this.fn = fn; + } + + final CF tryFire(int mode) { + CF d; + CF a; + CF b; + Object r; + Throwable x; + Runnable f; + if ((d = dep) == null || (f = fn) == null + || (a = src) == null || (b = snd) == null + || ((r = a.result) == null && (r = b.result) == null)) { + return null; + } + if (d.result == null) { + try { + if (mode <= 0 && !claim()) { + return null; + } else if (r instanceof AltResult + && (x = ((AltResult) r).ex) != null) { + d.completeThrowable(x, r); + } else { + f.run(); + d.completeNull(); + } + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + dep = null; + src = null; + snd = null; + fn = null; + return d.postFire(a, b, mode); + } + } + + private CF orRunStage(Executor e, CompletionStage o, + Runnable f) { + CF b; + if (f == null || (b = (CF) o.toCompletableFuture()) == null) { + throw new NullPointerException(); + } + + Object r; + CF z; + if ((r = (z = this).result) != null || + (r = (z = b).result) != null) { + return z.uniRunNow(r, e, f); + } + + CF d = newIncompleteFuture(); + orpush(b, new OrRun<>(e, d, this, b, f)); + return d; + } + + /** + * Completion for an anyOf input future. + */ + @SuppressWarnings("serial") + static class AnyOf extends Completion { + CF dep; + CF src; + CF[] srcs; + + AnyOf(CF dep, CF src, + CF[] srcs) { + this.dep = dep; + this.src = src; + this.srcs = srcs; + } + + final CF tryFire(int mode) { + // assert mode != ASYNC; + CF d; + CF a; + CF[] as; + Object r; + if ((d = dep) == null + || (a = src) == null || (r = a.result) == null + || (as = srcs) == null) { + return null; + } + dep = null; + src = null; + srcs = null; + if (d.completeRelay(r)) { + for (CF b : as) { + if (b != a) { + b.cleanStack(); + } + } + if (mode < 0) { + return d; + } else { + d.postComplete(); + } + } + return null; + } + + final boolean isLive() { + CF d; + return (d = dep) != null && d.result == null; + } + } + + /* ------------- Zero-input Async forms -------------- */ + + @SuppressWarnings("serial") + static final class AsyncSupply extends ForkJoinTask + implements Runnable, AsynchronousCompletionTask { + CF dep; + Supplier fn; + + AsyncSupply(CF dep, Supplier fn) { + this.dep = dep; + this.fn = fn; + } + + public final Void getRawResult() { + return null; + } + + public final void setRawResult(Void v) { + } + + public final boolean exec() { + run(); + return false; + } + + public void run() { + CF d; + Supplier f; + if ((d = dep) != null && (f = fn) != null) { + dep = null; + fn = null; + if (d.result == null) { + try { + d.completeValue(f.get()); + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + d.postComplete(); + } + } + } + + static CF asyncSupplyStage(Executor e, + Supplier f) { + if (f == null) { + throw new NullPointerException(); + } + CF d = new CF(); + e.execute(new AsyncSupply(d, f)); + return d; + } + + @SuppressWarnings("serial") + static final class AsyncRun extends ForkJoinTask + implements Runnable, AsynchronousCompletionTask { + CF dep; + Runnable fn; + + AsyncRun(CF dep, Runnable fn) { + this.dep = dep; + this.fn = fn; + } + + public final Void getRawResult() { + return null; + } + + public final void setRawResult(Void v) { + } + + public final boolean exec() { + run(); + return false; + } + + public void run() { + CF d; + Runnable f; + if ((d = dep) != null && (f = fn) != null) { + dep = null; + fn = null; + if (d.result == null) { + try { + f.run(); + d.completeNull(); + } catch (Throwable ex) { + d.completeThrowable(ex); + } + } + d.postComplete(); + } + } + } + + static CF asyncRunStage(Executor e, Runnable f) { + if (f == null) { + throw new NullPointerException(); + } + CF d = new CF(); + e.execute(new AsyncRun(d, f)); + return d; + } + + /* ------------- Signallers -------------- */ + + /** + * Completion for recording and releasing a waiting thread. This + * class implements ManagedBlocker to avoid starvation when + * blocking actions pile up in ForkJoinPools. + */ + @SuppressWarnings("serial") + static final class Signaller extends Completion + implements ForkJoinPool.ManagedBlocker { + long nanos; // remaining wait time if timed + final long deadline; // non-zero if timed + final boolean interruptible; + boolean interrupted; + volatile Thread thread; + + Signaller(boolean interruptible, long nanos, long deadline) { + this.thread = Thread.currentThread(); + this.interruptible = interruptible; + this.nanos = nanos; + this.deadline = deadline; + } + + final CF tryFire(int ignore) { + Thread w; // no need to atomically claim + if ((w = thread) != null) { + thread = null; + LockSupport.unpark(w); + } + return null; + } + + public boolean isReleasable() { + if (Thread.interrupted()) { + interrupted = true; + } + return ((interrupted && interruptible) || + (deadline != 0L && + (nanos <= 0L || + (nanos = deadline - System.nanoTime()) <= 0L)) || + thread == null); + } + + public boolean block() { + while (!isReleasable()) { + if (deadline == 0L) { + LockSupport.park(this); + } else { + LockSupport.parkNanos(this, nanos); + } + } + return true; + } + + final boolean isLive() { + return thread != null; + } + } + + /** + * Returns raw result after waiting, or null if interruptible and + * interrupted. + */ + private Object waitingGet(boolean interruptible) { +// throw new UnsupportedOperationException(); + Signaller q = null; + boolean queued = false; + Object r; + while ((r = result) == null) { + if (q == null) { + q = new Signaller(interruptible, 0L, 0L); +// if (Thread.currentThread() instanceof ForkJoinWorkerThread) { +// ForkJoinPool.helpAsyncBlocker(defaultExecutor(), q); +// } + } else if (!queued) { + queued = tryPushStack(q); + } else { + try { + ForkJoinPool.managedBlock(q); + } catch (InterruptedException ie) { // currently cannot happen + q.interrupted = true; + } + if (q.interrupted && interruptible) { + break; + } + } + } + if (q != null && queued) { + q.thread = null; + if (!interruptible && q.interrupted) { + Thread.currentThread().interrupt(); + } + if (r == null) { + cleanStack(); + } + } + if (r != null || (r = result) != null) { + postComplete(); + } + return r; + } + + /** + * Returns raw result after waiting, or null if interrupted, or + * throws TimeoutException on timeout. + */ + private Object timedGet(long nanos) throws TimeoutException { +// throw new UnsupportedOperationException(); + if (Thread.interrupted()) { + return null; + } + if (nanos > 0L) { + long d = System.nanoTime() + nanos; + long deadline = (d == 0L) ? 1L : d; // avoid 0 + Signaller q = null; + boolean queued = false; + Object r; + while ((r = result) == null) { // similar to untimed + if (q == null) { + q = new Signaller(true, nanos, deadline); +// if (Thread.currentThread() instanceof ForkJoinWorkerThread) { +// ForkJoinPool.helpAsyncBlocker(defaultExecutor(), q); +// } + } else if (!queued) { + queued = tryPushStack(q); + } else if (q.nanos <= 0L) { + break; + } else { + try { + ForkJoinPool.managedBlock(q); + } catch (InterruptedException ie) { + q.interrupted = true; + } + if (q.interrupted) { + break; + } + } + } + if (q != null && queued) { + q.thread = null; + if (r == null) { + cleanStack(); + } + } + if (r != null || (r = result) != null) { + postComplete(); + } + if (r != null || (q != null && q.interrupted)) { + return r; + } + } + throw new TimeoutException(); + } + + /* ------------- public methods -------------- */ + + public static CopyOnWriteArrayList> allNonBatchedCFs = new CopyOnWriteArrayList<>(); + public static List> batchedCFs = new CopyOnWriteArrayList<>(); + public static Set> completedCfs = ConcurrentHashMap.newKeySet(); + + /** + * Creates a new incomplete CF. + */ + public CF() { + newInstance(); + } + + /** + * Creates a new complete CF with given encoded result. + */ + CF(Object r) { + this.result = r; + newInstance(); + afterCompletedInternal(); + } + + private void newInstance() { + if ((this instanceof ToBatchCF)) { + System.out.println("NEW Batch instance"); + batchedCFs.add(this); + } else { + allNonBatchedCFs.add(this); + System.out.println("new CF instance " + this + " total count" + allNonBatchedCFs.size()); + } + } + + private void afterCompletedInternal() { + if (this.result != null) { + completedCfs.add(this); + System.out.println("completed CF instance " + this + " completed count: " + completedCfs.size()); + if (completedCfs.size() == allNonBatchedCFs.size()) { + // Now it is time to resolve the Batched CFs + // ... trigger DataLoader here + } + } + } + + private void assignResult(Object r) { + this.result = r; + afterCompletedInternal(); + } + + /** + * Returns a new CF that is asynchronously completed + * by a task running in the {@link ForkJoinPool#commonPool()} with + * the value obtained by calling the given Supplier. + * + * @param supplier a function returning the value to be used + * to complete the returned CF + * @param the function's return type + * + * @return the new CF + */ + public static CF supplyAsync(Supplier supplier) { + return asyncSupplyStage(ASYNC_POOL, supplier); + } + + /** + * Returns a new CF that is asynchronously completed + * by a task running in the given executor with the value obtained + * by calling the given Supplier. + * + * @param supplier a function returning the value to be used + * to complete the returned CF + * @param executor the executor to use for asynchronous execution + * @param the function's return type + * + * @return the new CF + */ + public static CF supplyAsync(Supplier supplier, + Executor executor) { + return asyncSupplyStage(screenExecutor(executor), supplier); + } + + /** + * Returns a new CF that is asynchronously completed + * by a task running in the {@link ForkJoinPool#commonPool()} after + * it runs the given action. + * + * @param runnable the action to run before completing the + * returned CF + * + * @return the new CF + */ + public static CF runAsync(Runnable runnable) { + return asyncRunStage(ASYNC_POOL, runnable); + } + + /** + * Returns a new CF that is asynchronously completed + * by a task running in the given executor after it runs the given + * action. + * + * @param runnable the action to run before completing the + * returned CF + * @param executor the executor to use for asynchronous execution + * + * @return the new CF + */ + public static CF runAsync(Runnable runnable, + Executor executor) { + return asyncRunStage(screenExecutor(executor), runnable); + } + + /** + * Returns a new CF that is already completed with + * the given value. + * + * @param value the value + * @param the type of the value + * + * @return the completed CF + */ + public static CF completedFuture(U value) { + return new CF<>((value == null) ? NIL : value); + } + + /** + * Returns {@code true} if completed in any fashion: normally, + * exceptionally, or via cancellation. + * + * @return {@code true} if completed + */ + public boolean isDone() { + return result != null; + } + + /** + * Waits if necessary for this future to complete, and then + * returns its result. + * + * @return the result value + * + * @throws CancellationException if this future was cancelled + * @throws ExecutionException if this future completed exceptionally + * @throws InterruptedException if the current thread was interrupted + * while waiting + */ + @SuppressWarnings("unchecked") + public T get() throws InterruptedException, ExecutionException { + Object r; + if ((r = result) == null) { + r = waitingGet(true); + } + return (T) reportGet(r); + } + + /** + * Waits if necessary for at most the given time for this future + * to complete, and then returns its result, if available. + * + * @param timeout the maximum time to wait + * @param unit the time unit of the timeout argument + * + * @return the result value + * + * @throws CancellationException if this future was cancelled + * @throws ExecutionException if this future completed exceptionally + * @throws InterruptedException if the current thread was interrupted + * while waiting + * @throws TimeoutException if the wait timed out + */ + @SuppressWarnings("unchecked") + public T get(long timeout, TimeUnit unit) + throws InterruptedException, ExecutionException, TimeoutException { + long nanos = unit.toNanos(timeout); + Object r; + if ((r = result) == null) { + r = timedGet(nanos); + } + return (T) reportGet(r); + } + + /** + * Returns the result value when complete, or throws an + * (unchecked) exception if completed exceptionally. To better + * conform with the use of common functional forms, if a + * computation involved in the completion of this + * CF threw an exception, this method throws an + * (unchecked) {@link CompletionException} with the underlying + * exception as its cause. + * + * @return the result value + * + * @throws CancellationException if the computation was cancelled + * @throws CompletionException if this future completed + * exceptionally or a completion computation threw an exception + */ + @SuppressWarnings("unchecked") + public T join() { + Object r; + if ((r = result) == null) { + r = waitingGet(false); + } + return (T) reportJoin(r); + } + + /** + * Returns the result value (or throws any encountered exception) + * if completed, else returns the given valueIfAbsent. + * + * @param valueIfAbsent the value to return if not completed + * + * @return the result value, if completed, else the given valueIfAbsent + * + * @throws CancellationException if the computation was cancelled + * @throws CompletionException if this future completed + * exceptionally or a completion computation threw an exception + */ + @SuppressWarnings("unchecked") + public T getNow(T valueIfAbsent) { + Object r; + return ((r = result) == null) ? valueIfAbsent : (T) reportJoin(r); + } + + /** + * If not already completed, sets the value returned by {@link + * #get()} and related methods to the given value. + * + * @param value the result value + * + * @return {@code true} if this invocation caused this CF + * to transition to a completed state, else {@code false} + */ + public boolean complete(T value) { + boolean triggered = completeValue(value); + postComplete(); + return triggered; + } + + /** + * If not already completed, causes invocations of {@link #get()} + * and related methods to throw the given exception. + * + * @param ex the exception + * + * @return {@code true} if this invocation caused this CF + * to transition to a completed state, else {@code false} + */ + public boolean completeExceptionally(Throwable ex) { + if (ex == null) { + throw new NullPointerException(); + } + boolean triggered = internalComplete(new AltResult(ex)); + postComplete(); + return triggered; + } + + public CF thenApply( + Function fn) { + return uniApplyStage(null, fn); + } + + public CF thenApplyAsync( + Function fn) { + return uniApplyStage(defaultExecutor(), fn); + } + + public CF thenApplyAsync( + Function fn, Executor executor) { + return uniApplyStage(screenExecutor(executor), fn); + } + + public CF thenAccept(Consumer action) { + return uniAcceptStage(null, action); + } + + public CF thenAcceptAsync(Consumer action) { + return uniAcceptStage(defaultExecutor(), action); + } + + public CF thenAcceptAsync(Consumer action, + Executor executor) { + return uniAcceptStage(screenExecutor(executor), action); + } + + public CF thenRun(Runnable action) { + return uniRunStage(null, action); + } + + public CF thenRunAsync(Runnable action) { + return uniRunStage(defaultExecutor(), action); + } + + public CF thenRunAsync(Runnable action, + Executor executor) { + return uniRunStage(screenExecutor(executor), action); + } + + public CF thenCombine( + CompletionStage other, + BiFunction fn) { + return biApplyStage(null, other, fn); + } + + public CF thenCombineAsync( + CompletionStage other, + BiFunction fn) { + return biApplyStage(defaultExecutor(), other, fn); + } + + public CF thenCombineAsync( + CompletionStage other, + BiFunction fn, Executor executor) { + return biApplyStage(screenExecutor(executor), other, fn); + } + + public CF thenAcceptBoth( + CompletionStage other, + BiConsumer action) { + return biAcceptStage(null, other, action); + } + + public CF thenAcceptBothAsync( + CompletionStage other, + BiConsumer action) { + return biAcceptStage(defaultExecutor(), other, action); + } + + public CF thenAcceptBothAsync( + CompletionStage other, + BiConsumer action, Executor executor) { + return biAcceptStage(screenExecutor(executor), other, action); + } + + public CF runAfterBoth(CompletionStage other, + Runnable action) { + return biRunStage(null, other, action); + } + + public CF runAfterBothAsync(CompletionStage other, + Runnable action) { + return biRunStage(defaultExecutor(), other, action); + } + + public CF runAfterBothAsync(CompletionStage other, + Runnable action, + Executor executor) { + return biRunStage(screenExecutor(executor), other, action); + } + + public CF applyToEither( + CompletionStage other, Function fn) { + return orApplyStage(null, other, fn); + } + + public CF applyToEitherAsync( + CompletionStage other, Function fn) { + return orApplyStage(defaultExecutor(), other, fn); + } + + public CF applyToEitherAsync( + CompletionStage other, Function fn, + Executor executor) { + return orApplyStage(screenExecutor(executor), other, fn); + } + + public CF acceptEither( + CompletionStage other, Consumer action) { + return orAcceptStage(null, other, action); + } + + public CF acceptEitherAsync( + CompletionStage other, Consumer action) { + return orAcceptStage(defaultExecutor(), other, action); + } + + public CF acceptEitherAsync( + CompletionStage other, Consumer action, + Executor executor) { + return orAcceptStage(screenExecutor(executor), other, action); + } + + public CF runAfterEither(CompletionStage other, + Runnable action) { + return orRunStage(null, other, action); + } + + public CF runAfterEitherAsync(CompletionStage other, + Runnable action) { + return orRunStage(defaultExecutor(), other, action); + } + + public CF runAfterEitherAsync(CompletionStage other, + Runnable action, + Executor executor) { + return orRunStage(screenExecutor(executor), other, action); + } + + public CF thenCompose( + Function> fn) { + return uniComposeStage(null, fn); + } + + public CF thenComposeAsync( + Function> fn) { + return uniComposeStage(defaultExecutor(), fn); + } + + public CF thenComposeAsync( + Function> fn, + Executor executor) { + return uniComposeStage(screenExecutor(executor), fn); + } + + public CF whenComplete( + BiConsumer action) { + return uniWhenCompleteStage(null, action); + } + + public CF whenCompleteAsync( + BiConsumer action) { + return uniWhenCompleteStage(defaultExecutor(), action); + } + + public CF whenCompleteAsync( + BiConsumer action, Executor executor) { + return uniWhenCompleteStage(screenExecutor(executor), action); + } + + public CF handle( + BiFunction fn) { + return uniHandleStage(null, fn); + } + + public CF handleAsync( + BiFunction fn) { + return uniHandleStage(defaultExecutor(), fn); + } + + public CF handleAsync( + BiFunction fn, Executor executor) { + return uniHandleStage(screenExecutor(executor), fn); + } + + /** + * Returns this CF. + * + * @return this CF + */ + @Override + public CF toCompletableFuture() { + return this; + } + + public CF exceptionally( + Function fn) { + return uniExceptionallyStage(null, fn); + } + + public CF exceptionallyAsync( + Function fn) { + return uniExceptionallyStage(defaultExecutor(), fn); + } + + public CF exceptionallyAsync( + Function fn, Executor executor) { + return uniExceptionallyStage(screenExecutor(executor), fn); + } + + public CF exceptionallyCompose( + Function> fn) { + return uniComposeExceptionallyStage(null, fn); + } + + public CF exceptionallyComposeAsync( + Function> fn) { + return uniComposeExceptionallyStage(defaultExecutor(), fn); + } + + public CF exceptionallyComposeAsync( + Function> fn, + Executor executor) { + return uniComposeExceptionallyStage(screenExecutor(executor), fn); + } + + /* ------------- Arbitrary-arity constructions -------------- */ + + /** + * Returns a new CF that is completed when all of + * the given CFs complete. If any of the given + * CFs complete exceptionally, then the returned + * CF also does so, with a CompletionException + * holding this exception as its cause. Otherwise, the results, + * if any, of the given CFs are not reflected in + * the returned CF, but may be obtained by + * inspecting them individually. If no CFs are + * provided, returns a CF completed with the value + * {@code null}. + * + *

Among the applications of this method is to await completion + * of a set of independent CFs before continuing a + * program, as in: {@code CF.allOf(c1, c2, + * c3).join();}. + * + * @param cfs the CFs + * + * @return a new CF that is completed when all of the + * given CFs complete + * + * @throws NullPointerException if the array or any of its elements are + * {@code null} + */ + public static CF allOf(CF... cfs) { + return andTree(cfs, 0, cfs.length - 1); + } + + /** + * Returns a new CF that is completed when any of + * the given CFs complete, with the same result. + * Otherwise, if it completed exceptionally, the returned + * CF also does so, with a CompletionException + * holding this exception as its cause. If no CFs + * are provided, returns an incomplete CF. + * + * @param cfs the CFs + * + * @return a new CF that is completed with the + * result or exception of any of the given CFs when + * one completes + * + * @throws NullPointerException if the array or any of its elements are + * {@code null} + */ + public static CF anyOf(CF... cfs) { + int n; + Object r; + if ((n = cfs.length) <= 1) { + return (n == 0) + ? new CF() + : uniCopyStage(cfs[0]); + } + for (CF cf : cfs) { + if ((r = cf.result) != null) { + return new CF(encodeRelay(r)); + } + } + cfs = cfs.clone(); + CF d = new CF<>(); + for (CF cf : cfs) { + cf.unipush(new AnyOf(d, cf, cfs)); + } + // If d was completed while we were adding completions, we should + // clean the stack of any sources that may have had completions + // pushed on their stack after d was completed. + if (d.result != null) { + for (int i = 0, len = cfs.length; i < len; i++) { + if (cfs[i].result != null) { + for (i++; i < len; i++) { + if (cfs[i].result == null) { + cfs[i].cleanStack(); + } + } + } + } + } + return d; + } + + /* ------------- Control and status methods -------------- */ + + /** + * If not already completed, completes this CF with + * a {@link CancellationException}. Dependent CFs + * that have not already completed will also complete + * exceptionally, with a {@link CompletionException} caused by + * this {@code CancellationException}. + * + * @param mayInterruptIfRunning this value has no effect in this + * implementation because interrupts are not used to control + * processing. + * + * @return {@code true} if this task is now cancelled + */ + public boolean cancel(boolean mayInterruptIfRunning) { + boolean cancelled = (result == null) && + internalComplete(new AltResult(new CancellationException())); + postComplete(); + return cancelled || isCancelled(); + } + + + /** + * Returns {@code true} if this CF was cancelled + * before it completed normally. + * + * @return {@code true} if this CF was cancelled + * before it completed normally + */ + public boolean isCancelled() { + Object r; + return ((r = result) instanceof AltResult) && + (((AltResult) r).ex instanceof CancellationException); + } + + /** + * Returns {@code true} if this CF completed + * exceptionally, in any way. Possible causes include + * cancellation, explicit invocation of {@code + * completeExceptionally}, and abrupt termination of a + * CompletionStage action. + * + * @return {@code true} if this CF completed + * exceptionally + */ + public boolean isCompletedExceptionally() { + Object r; + return ((r = result) instanceof AltResult) && r != NIL; + } + + /** + * Forcibly sets or resets the value subsequently returned by + * method {@link #get()} and related methods, whether or not + * already completed. This method is designed for use only in + * error recovery actions, and even in such situations may result + * in ongoing dependent completions using established versus + * overwritten outcomes. + * + * @param value the completion value + */ + public void obtrudeValue(T value) { + assignResult(value == null ? NIL : value); + postComplete(); + } + + /** + * Forcibly causes subsequent invocations of method {@link #get()} + * and related methods to throw the given exception, whether or + * not already completed. This method is designed for use only in + * error recovery actions, and even in such situations may result + * in ongoing dependent completions using established versus + * overwritten outcomes. + * + * @param ex the exception + * + * @throws NullPointerException if the exception is null + */ + public void obtrudeException(Throwable ex) { + if (ex == null) { + throw new NullPointerException(); + } + assignResult(new AltResult(ex)); + postComplete(); + } + + /** + * Returns the estimated number of CFs whose + * completions are awaiting completion of this CF. + * This method is designed for use in monitoring system state, not + * for synchronization control. + * + * @return the number of dependent CFs + */ + public int getNumberOfDependents() { + int count = 0; + for (Completion p = stack; p != null; p = p.next) { + ++count; + } + return count; + } + + /** + * Returns a string identifying this CF, as well as + * its completion state. The state, in brackets, contains the + * String {@code "Completed Normally"} or the String {@code + * "Completed Exceptionally"}, or the String {@code "Not + * completed"} followed by the number of CFs + * dependent upon its completion, if any. + * + * @return a string identifying this CF, as well as its state + */ + public String toString() { + Object r = result; + int count = 0; // avoid call to getNumberOfDependents in case disabled + for (Completion p = stack; p != null; p = p.next) { + ++count; + } + return getClass().getName() + "@" + Integer.toHexString(hashCode()) + + ((r == null) + ? ((count == 0) + ? "[Not completed]" + : "[Not completed, " + count + " dependents]") + : (((r instanceof AltResult) && ((AltResult) r).ex != null) + ? "[Completed exceptionally: " + ((AltResult) r).ex + "]" + : "[Completed normally]")); + } + + public void printStack() { + printStackImpl(0); + } + + private void printStackImpl(int level) { + StringBuilder sb = new StringBuilder(); + int count = 0; + System.out.println(this); + for (Completion p = stack; p != null; p = p.next) { + if (p instanceof UniCompletion) { + System.out.println(" ".repeat(level) + "dependent " + ((UniCompletion) p).dep); + ((UniCompletion) p).dep.printStackImpl(level++); + } + } + + } + + // jdk9 additions + + /** + * Returns a new incomplete CF of the type to be + * returned by a CompletionStage method. Subclasses should + * normally override this method to return an instance of the same + * class as this CF. The default implementation + * returns an instance of class CF. + * + * @param the type of the value + * + * @return a new CF + * + * @since 9 + */ + public CF newIncompleteFuture() { + return new CF(); + } + + /** + * Returns the default Executor used for async methods that do not + * specify an Executor. This class uses the {@link + * ForkJoinPool#commonPool()} if it supports more than one + * parallel thread, or else an Executor using one thread per async + * task. This method may be overridden in subclasses to return + * an Executor that provides at least one independent thread. + * + * @return the executor + * + * @since 9 + */ + public Executor defaultExecutor() { + return ASYNC_POOL; + } + + /** + * Returns a new CF that is completed normally with + * the same value as this CF when it completes + * normally. If this CF completes exceptionally, + * then the returned CF completes exceptionally + * with a CompletionException with this exception as cause. The + * behavior is equivalent to {@code thenApply(x -> x)}. This + * method may be useful as a form of "defensive copying", to + * prevent clients from completing, while still being able to + * arrange dependent actions. + * + * @return the new CF + * + * @since 9 + */ + public CF copy() { + return uniCopyStage(this); + } + + /** + * Returns a new CompletionStage that is completed normally with + * the same value as this CF when it completes + * normally, and cannot be independently completed or otherwise + * used in ways not defined by the methods of interface {@link + * CompletionStage}. If this CF completes + * exceptionally, then the returned CompletionStage completes + * exceptionally with a CompletionException with this exception as + * cause. + * + *

Unless overridden by a subclass, a new non-minimal + * CF with all methods available can be obtained from + * a minimal CompletionStage via {@link #toCompletableFuture()}. + * For example, completion of a minimal stage can be awaited by + * + * 

 {@code minimalStage.toCF().join(); }
+ * + * @return the new CompletionStage + * + * @since 9 + */ + public CompletionStage minimalCompletionStage() { + return uniAsMinimalStage(); + } + + /** + * Completes this CF with the result of + * the given Supplier function invoked from an asynchronous + * task using the given executor. + * + * @param supplier a function returning the value to be used + * to complete this CF + * @param executor the executor to use for asynchronous execution + * + * @return this CF + * + * @since 9 + */ + public CF completeAsync(Supplier supplier, + Executor executor) { + if (supplier == null || executor == null) { + throw new NullPointerException(); + } + executor.execute(new AsyncSupply(this, supplier)); + return this; + } + + /** + * Completes this CF with the result of the given + * Supplier function invoked from an asynchronous task using the + * default executor. + * + * @param supplier a function returning the value to be used + * to complete this CF + * + * @return this CF + * + * @since 9 + */ + public CF completeAsync(Supplier supplier) { + return completeAsync(supplier, defaultExecutor()); + } + + /** + * Exceptionally completes this CF with + * a {@link TimeoutException} if not otherwise completed + * before the given timeout. + * + * @param timeout how long to wait before completing exceptionally + * with a TimeoutException, in units of {@code unit} + * @param unit a {@code TimeUnit} determining how to interpret the + * {@code timeout} parameter + * + * @return this CF + * + * @since 9 + */ + public CF orTimeout(long timeout, TimeUnit unit) { + if (unit == null) { + throw new NullPointerException(); + } + if (result == null) { + whenComplete(new Canceller(Delayer.delay(new Timeout(this), + timeout, unit))); + } + return this; + } + + /** + * Completes this CF with the given value if not + * otherwise completed before the given timeout. + * + * @param value the value to use upon timeout + * @param timeout how long to wait before completing normally + * with the given value, in units of {@code unit} + * @param unit a {@code TimeUnit} determining how to interpret the + * {@code timeout} parameter + * + * @return this CF + * + * @since 9 + */ + public CF completeOnTimeout(T value, long timeout, + TimeUnit unit) { + if (unit == null) { + throw new NullPointerException(); + } + if (result == null) { + whenComplete(new Canceller(Delayer.delay( + new DelayedCompleter(this, value), + timeout, unit))); + } + return this; + } + + /** + * Returns a new Executor that submits a task to the given base + * executor after the given delay (or no delay if non-positive). + * Each delay commences upon invocation of the returned executor's + * {@code execute} method. + * + * @param delay how long to delay, in units of {@code unit} + * @param unit a {@code TimeUnit} determining how to interpret the + * {@code delay} parameter + * @param executor the base executor + * + * @return the new delayed executor + * + * @since 9 + */ + public static Executor delayedExecutor(long delay, TimeUnit unit, + Executor executor) { + if (unit == null || executor == null) { + throw new NullPointerException(); + } + return new DelayedExecutor(delay, unit, executor); + } + + /** + * Returns a new Executor that submits a task to the default + * executor after the given delay (or no delay if non-positive). + * Each delay commences upon invocation of the returned executor's + * {@code execute} method. + * + * @param delay how long to delay, in units of {@code unit} + * @param unit a {@code TimeUnit} determining how to interpret the + * {@code delay} parameter + * + * @return the new delayed executor + * + * @since 9 + */ + public static Executor delayedExecutor(long delay, TimeUnit unit) { + if (unit == null) { + throw new NullPointerException(); + } + return new DelayedExecutor(delay, unit, ASYNC_POOL); + } + + /** + * Returns a new CompletionStage that is already completed with + * the given value and supports only those methods in + * interface {@link CompletionStage}. + * + * @param value the value + * @param the type of the value + * + * @return the completed CompletionStage + * + * @since 9 + */ + public static CompletionStage completedStage(U value) { + return new MinimalStage((value == null) ? NIL : value); + } + + /** + * Returns a new CF that is already completed + * exceptionally with the given exception. + * + * @param ex the exception + * @param the type of the value + * + * @return the exceptionally completed CF + * + * @since 9 + */ + public static CF failedFuture(Throwable ex) { + if (ex == null) { + throw new NullPointerException(); + } + return new CF(new AltResult(ex)); + } + + public static CF wrap( + CompletableFuture completableFuture) { + if (completableFuture instanceof CF) { + return (CF) completableFuture; + } + CF cf = new CF<>(); + completableFuture.whenComplete((u, ex) -> { + if (ex != null) { + cf.completeExceptionally(ex); + } else { + cf.complete(u); + } + }); + return cf; + } + + /** + * Returns a new CompletionStage that is already completed + * exceptionally with the given exception and supports only those + * methods in interface {@link CompletionStage}. + * + * @param ex the exception + * @param the type of the value + * + * @return the exceptionally completed CompletionStage + * + * @since 9 + */ + public static CompletionStage failedStage(Throwable ex) { + if (ex == null) { + throw new NullPointerException(); + } + return new MinimalStage(new AltResult(ex)); + } + + /** + * Singleton delay scheduler, used only for starting and + * cancelling tasks. + */ + static final class Delayer { + static ScheduledFuture delay(Runnable command, long delay, + TimeUnit unit) { + return delayer.schedule(command, delay, unit); + } + + static final class DaemonThreadFactory implements ThreadFactory { + public Thread newThread(Runnable r) { + Thread t = new Thread(r); + t.setDaemon(true); + t.setName("CFDelayScheduler"); + return t; + } + } + + static final ScheduledThreadPoolExecutor delayer; + + static { + (delayer = new ScheduledThreadPoolExecutor( + 1, new DaemonThreadFactory())). + setRemoveOnCancelPolicy(true); + } + } + + // Little class-ified lambdas to better support monitoring + + static final class DelayedExecutor implements Executor { + final long delay; + final TimeUnit unit; + final Executor executor; + + DelayedExecutor(long delay, TimeUnit unit, Executor executor) { + this.delay = delay; + this.unit = unit; + this.executor = executor; + } + + public void execute(Runnable r) { + Delayer.delay(new TaskSubmitter(executor, r), delay, unit); + } + } + + /** + * Action to submit user task + */ + static final class TaskSubmitter implements Runnable { + final Executor executor; + final Runnable action; + + TaskSubmitter(Executor executor, Runnable action) { + this.executor = executor; + this.action = action; + } + + public void run() { + executor.execute(action); + } + } + + /** + * Action to completeExceptionally on timeout + */ + static final class Timeout implements Runnable { + final CF f; + + Timeout(CF f) { + this.f = f; + } + + public void run() { + if (f != null && !f.isDone()) { + f.completeExceptionally(new TimeoutException()); + } + } + } + + /** + * Action to complete on timeout + */ + static final class DelayedCompleter implements Runnable { + final CF f; + final U u; + + DelayedCompleter(CF f, U u) { + this.f = f; + this.u = u; + } + + public void run() { + if (f != null) { + f.complete(u); + } + } + } + + /** + * Action to cancel unneeded timeouts + */ + static final class Canceller implements BiConsumer { + final Future f; + + Canceller(Future f) { + this.f = f; + } + + public void accept(Object ignore, Throwable ex) { + if (ex == null && f != null && !f.isDone()) { + f.cancel(false); + } + } + } + + /** + * A subclass that just throws UOE for most non-CompletionStage methods. + */ + static final class MinimalStage extends CF { + MinimalStage() { + } + + MinimalStage(Object r) { + super(r); + } + + @Override + public CF newIncompleteFuture() { + return new MinimalStage(); + } + + @Override + public T get() { + throw new UnsupportedOperationException(); + } + + @Override + public T get(long timeout, TimeUnit unit) { + throw new UnsupportedOperationException(); + } + + @Override + public T getNow(T valueIfAbsent) { + throw new UnsupportedOperationException(); + } + + @Override + public T join() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean complete(T value) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean completeExceptionally(Throwable ex) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean cancel(boolean mayInterruptIfRunning) { + throw new UnsupportedOperationException(); + } + + @Override + public void obtrudeValue(T value) { + throw new UnsupportedOperationException(); + } + + @Override + public void obtrudeException(Throwable ex) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isDone() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isCancelled() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isCompletedExceptionally() { + throw new UnsupportedOperationException(); + } + + @Override + public int getNumberOfDependents() { + throw new UnsupportedOperationException(); + } + + @Override + public CF completeAsync + (Supplier supplier, Executor executor) { + throw new UnsupportedOperationException(); + } + + @Override + public CF completeAsync + (Supplier supplier) { + throw new UnsupportedOperationException(); + } + + @Override + public CF orTimeout + (long timeout, TimeUnit unit) { + throw new UnsupportedOperationException(); + } + + @Override + public CF completeOnTimeout + (T value, long timeout, TimeUnit unit) { + throw new UnsupportedOperationException(); + } + + @Override + public CF toCompletableFuture() { + Object r; + if ((r = result) != null) { + return new CF(encodeRelay(r)); + } else { + CF d = new CF<>(); + unipush(new UniRelay(d, this)); + return d; + } + } + } + + private static class ToBatchCF extends CF { + + final String batchName; + + private ToBatchCF(String batchName) { + this.batchName = batchName; + } + } + + public static CF newBatchCF(String name) { + return new ToBatchCF<>(name); + } + + // Replaced misc unsafe with VarHandle + private static final VarHandle RESULT; + private static final VarHandle STACK; + private static final VarHandle NEXT; + + static { + try { + MethodHandles.Lookup l = MethodHandles.lookup(); + RESULT = l.findVarHandle(CF.class, "result", Object.class); + STACK = l.findVarHandle(CF.class, "stack", CF.Completion.class); + NEXT = l.findVarHandle(CF.Completion.class, "next", CF.Completion.class); + } catch (ReflectiveOperationException e) { + throw new Error(e); + } + + // Reduce the risk of rare disastrous classloading in first call to + // LockSupport.park: https://bugs.openjdk.java.net/browse/JDK-8074773 + Class ensureLoaded = LockSupport.class; + } + + + public static void main(String[] args) { + CompletableFuture future = new CompletableFuture<>(); + CF cf = new CF<>(); + // on the CompletableFuture level cf has a dependent on overall + CompletableFuture overall = future.thenCompose(o -> cf); + + overall.whenComplete((o, throwable) -> + System.out.println("Future completed with: " + o) + ); + future.complete(null); + cf.complete(null); + + cf.thenCompose(x -> { + // some worka + return new CF<>(); + }); + // then compose is a two step: first the outer -> then the function -> then the result of the function + + } +} + + diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java index 3b45786533..6cd3888380 100644 --- a/src/main/java/graphql/execution/ExecutionStrategy.java +++ b/src/main/java/graphql/execution/ExecutionStrategy.java @@ -215,7 +215,7 @@ protected Object executeObject(ExecutionContext executionContext, ExecutionStrat DeferredExecutionSupport deferredExecutionSupport = createDeferredExecutionSupport(executionContext, parameters); Async.CombinedBuilder resolvedFieldFutures = getAsyncFieldValueInfo(executionContext, parameters, deferredExecutionSupport); - CompletableFuture> overallResult = new CompletableFuture<>(); + CompletableFuture> overallResult = new CF<>(); List fieldsExecutedOnInitialResult = deferredExecutionSupport.getNonDeferredFieldNames(fieldNames); BiConsumer, Throwable> handleResultsConsumer = buildFieldValueMap(fieldsExecutedOnInitialResult, overallResult, executionContext); @@ -828,7 +828,7 @@ protected FieldValueInfo completeValueForList(ExecutionContext executionContext, if (listResults instanceof CompletableFuture) { @SuppressWarnings("unchecked") CompletableFuture> resultsFuture = (CompletableFuture>) listResults; - CompletableFuture overallResult = new CompletableFuture<>(); + CompletableFuture overallResult = new CF<>(); completeListCtx.onDispatched(); overallResult.whenComplete(completeListCtx::onCompleted); diff --git a/src/main/java/graphql/execution/instrumentation/Instrumentation.java b/src/main/java/graphql/execution/instrumentation/Instrumentation.java index 714f96fe3c..2ebaec624c 100644 --- a/src/main/java/graphql/execution/instrumentation/Instrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/Instrumentation.java @@ -4,6 +4,7 @@ import graphql.ExecutionResult; import graphql.ExperimentalApi; import graphql.PublicSpi; +import graphql.execution.CF; import graphql.execution.ExecutionContext; import graphql.execution.instrumentation.parameters.InstrumentationCreateStateParameters; import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters; @@ -339,6 +340,6 @@ default DataFetcher instrumentDataFetcher(DataFetcher dataFetcher, Instrum */ @NonNull default CompletableFuture instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) { - return CompletableFuture.completedFuture(executionResult); + return CF.completedFuture(executionResult); } } diff --git a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java index 03a96776b6..ffe67b10eb 100644 --- a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java +++ b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java @@ -3,6 +3,7 @@ import graphql.ExecutionInput; import graphql.Internal; +import graphql.execution.CF; import java.util.concurrent.CompletableFuture; import java.util.function.Function; @@ -13,6 +14,6 @@ public class NoOpPreparsedDocumentProvider implements PreparsedDocumentProvider @Override public CompletableFuture getDocumentAsync(ExecutionInput executionInput, Function parseAndValidateFunction) { - return CompletableFuture.completedFuture(parseAndValidateFunction.apply(executionInput)); + return CF.completedFuture(parseAndValidateFunction.apply(executionInput)); } } diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index 7b9c48ad7d..a37ba35916 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -92,6 +92,40 @@ class GraphQLTest extends Specification { result == [hello: 'world'] } + def "to batch"() { + given: + def sdl = ''' + + type Query { + dogName: String + catName: String + } + ''' + def df1 = { env -> +// return CF.newBatchCF("animalName1").thenCompose { it -> CF.newBatchCF("animalName2") } + return "Luna" + } as DataFetcher + + def df2 = { env -> +// return CF.newBatchCF("animalName1").thenCompose { it -> CF.newBatchCF("animalName2") } + return "Tiger" + } as DataFetcher + + + def fetchers = ["Query": ["dogName": df1, "catName": df2]] + def schema = TestUtil.schema(sdl, fetchers) + def graphQL = GraphQL.newGraphQL(schema).build() + + def query = "{ dogName catName } " + def ei = newExecutionInput(query).build() + + when: + def er = graphQL.execute(ei) + then: + er.data == [hello: "world"] + } + + def "query with sub-fields"() { given: GraphQLObjectType heroType = newObject() From efc2f50830a71995d52fef7bbf0e342696a526a8 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 15:14:28 +1000 Subject: [PATCH 02/19] very very wip --- src/main/java/graphql/GraphQL.java | 2 +- src/main/java/graphql/execution/Async.java | 4 +- .../execution/AsyncExecutionStrategy.java | 3 +- .../AsyncSerialExecutionStrategy.java | 2 +- src/main/java/graphql/execution/CF.java | 200 ++++++++++++++---- .../PerLevelDataLoaderDispatchStrategy.java | 4 +- .../NoOpPreparsedDocumentProvider.java | 2 +- src/test/groovy/graphql/GraphQLTest.groovy | 46 +++- 8 files changed, 211 insertions(+), 52 deletions(-) diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index acfb7adc3a..c7a3f00579 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -475,7 +475,7 @@ private CF parseValidateAndExecute(ExecutionInput executionInpu CF preparsedDoc = CF.wrap(preparsedDocumentProvider.getDocumentAsync(executionInput, computeFunction)); return preparsedDoc.thenCompose(preparsedDocumentEntry -> { if (preparsedDocumentEntry.hasErrors()) { - return CF.completedFuture(new ExecutionResultImpl(preparsedDocumentEntry.getErrors())); + return CF.completedEngineCF(new ExecutionResultImpl(preparsedDocumentEntry.getErrors())); } try { return execute(executionInputRef.get(), preparsedDocumentEntry.getDocument(), graphQLSchema, instrumentationState); diff --git a/src/main/java/graphql/execution/Async.java b/src/main/java/graphql/execution/Async.java index f28b048edd..644ed8b276 100644 --- a/src/main/java/graphql/execution/Async.java +++ b/src/main/java/graphql/execution/Async.java @@ -194,12 +194,12 @@ public void addObject(Object object) { public CompletableFuture> await() { commonSizeAssert(); - CF> overallResult = new CF<>(); + CF> overallResult = CF.newEngineCF(); if (cfCount == 0) { overallResult.complete(materialisedList(array)); } else { CF[] cfsArr = copyOnlyCFsToArray(); - CF.allOf(cfsArr) + CF.allOfEngineCFs(cfsArr) .whenComplete((ignored, exception) -> { if (exception != null) { overallResult.completeExceptionally(exception); diff --git a/src/main/java/graphql/execution/AsyncExecutionStrategy.java b/src/main/java/graphql/execution/AsyncExecutionStrategy.java index 3e815e85bb..1ab08864e4 100644 --- a/src/main/java/graphql/execution/AsyncExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncExecutionStrategy.java @@ -56,7 +56,8 @@ public CompletableFuture execute(ExecutionContext executionCont DeferredExecutionSupport deferredExecutionSupport = createDeferredExecutionSupport(executionContext, parameters); Async.CombinedBuilder futures = getAsyncFieldValueInfo(executionContext, parameters, deferredExecutionSupport); - CF overallResult = new CF<>(); + // can be waiting on DataFetcher completion, therefore it is a engine cCF + CF overallResult = CF.newEngineCF(); executionStrategyCtx.onDispatched(); futures.await().whenComplete((completeValueInfos, throwable) -> { diff --git a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java index ba0796b03e..a8a7feb39f 100644 --- a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java @@ -58,7 +58,7 @@ public CompletableFuture execute(ExecutionContext executionCont return resolveSerialField(executionContext, dataLoaderDispatcherStrategy, newParameters); }); - CF overallResult = new CF<>(); + CF overallResult = CF.newEngineCF(); executionStrategyCtx.onDispatched(); resultsFuture.whenComplete(handleResults(executionContext, fieldNames, overallResult)); diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index 0965d17963..5f1093f13d 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -6,11 +6,12 @@ * http://creativecommons.org/publicdomain/zero/1.0/ */ -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import graphql.schema.DataFetchingEnvironment; +import org.dataloader.DataLoaderRegistry; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; +import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.concurrent.CancellationException; @@ -19,6 +20,7 @@ import java.util.concurrent.CompletionStage; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor; import java.util.concurrent.ForkJoinPool; @@ -135,7 +137,6 @@ * @since 1.8 */ public class CF extends CompletableFuture { - private static final Logger log = LoggerFactory.getLogger(CF.class); /* * Overview: @@ -1337,7 +1338,11 @@ final CF tryFire(int mode) { return null; } @SuppressWarnings("unchecked") T t = (T) r; - CF g = (CF) f.apply(t).toCompletableFuture(); + CompletionStage apply = f.apply(t).toCompletableFuture(); + if (!(apply instanceof CF)) { + System.out.println("mmm"); + } + CF g = (CF) apply; if ((r = g.result) != null) { d.completeRelay(r); } else { @@ -1801,6 +1806,38 @@ static CF andTree(CF[] cfs, return d; } + static CF andTreeEngine(CF[] cfs, + int lo, int hi) { + CF d = new EngineCF<>(); + if (lo > hi) // empty + { + d.assignResult(NIL); + } else { + CF a, b; + Object r, s, z; + Throwable x; + int mid = (lo + hi) >>> 1; + if ((a = (lo == mid ? cfs[lo] : + andTreeEngine(cfs, lo, mid))) == null || + (b = (lo == hi ? a : (hi == mid + 1) ? cfs[hi] : + andTreeEngine(cfs, mid + 1, hi))) == null) { + throw new NullPointerException(); + } + if ((r = a.result) == null || (s = b.result) == null) { + a.bipush(b, new BiRelay<>(d, a, b)); + } else if ((r instanceof AltResult + && (x = ((AltResult) (z = r)).ex) != null) || + (s instanceof AltResult + && (x = ((AltResult) (z = s)).ex) != null)) { + d.assignResult(encodeThrowable(x, z)); + } else { + d.assignResult(NIL); + } + } + return d; + } + + /* ------------- Projected (Ored) BiCompletions -------------- */ /** @@ -2338,8 +2375,9 @@ private Object timedGet(long nanos) throws TimeoutException { /* ------------- public methods -------------- */ - public static CopyOnWriteArrayList> allNonBatchedCFs = new CopyOnWriteArrayList<>(); - public static List> batchedCFs = new CopyOnWriteArrayList<>(); + public static CopyOnWriteArrayList> allNormalCFs = new CopyOnWriteArrayList<>(); + public static List> dataLoaderCFs = new CopyOnWriteArrayList<>(); + public static List> completedDataLoaderCFs = new CopyOnWriteArrayList<>(); public static Set> completedCfs = ConcurrentHashMap.newKeySet(); /** @@ -2359,23 +2397,20 @@ public CF() { } private void newInstance() { - if ((this instanceof ToBatchCF)) { - System.out.println("NEW Batch instance"); - batchedCFs.add(this); + if ((this instanceof DataLoaderCF)) { + dataLoaderCFs.add((DataLoaderCF) this); + } else if ((this instanceof EngineCF)) { +// System.out.println("new Engine CF instance " + this); } else { - allNonBatchedCFs.add(this); - System.out.println("new CF instance " + this + " total count" + allNonBatchedCFs.size()); + allNormalCFs.add(this); +// System.out.println("new CF instance " + this + " total count" + allNormalCFs.size()); } } private void afterCompletedInternal() { - if (this.result != null) { + if (this.result != null && !(this instanceof DataLoaderCF) && !(this instanceof EngineCF)) { completedCfs.add(this); - System.out.println("completed CF instance " + this + " completed count: " + completedCfs.size()); - if (completedCfs.size() == allNonBatchedCFs.size()) { - // Now it is time to resolve the Batched CFs - // ... trigger DataLoader here - } +// System.out.println("completed CF instance " + this + " completed count: " + completedCfs.size()); } } @@ -2849,6 +2884,11 @@ public static CF allOf(CF... cfs) { return andTree(cfs, 0, cfs.length - 1); } + public static CF allOfEngineCFs(CF... cfs) { + return andTreeEngine(cfs, 0, cfs.length - 1); + } + + /** * Returns a new CF that is completed when any of * the given CFs complete, with the same result. @@ -3053,7 +3093,7 @@ private void printStackImpl(int level) { * returned by a CompletionStage method. Subclasses should * normally override this method to return an instance of the same * class as this CF. The default implementation - * returns an instance of class CF. + * returns an instance of class CompletableFuture. * * @param the type of the value * @@ -3298,7 +3338,7 @@ public static CF wrap( if (completableFuture instanceof CF) { return (CF) completableFuture; } - CF cf = new CF<>(); + EngineCF cf = new EngineCF<>(); completableFuture.whenComplete((u, ex) -> { if (ex != null) { cf.completeExceptionally(ex); @@ -3562,17 +3602,95 @@ public CF toCompletableFuture() { } } - private static class ToBatchCF extends CF { + private static class EngineCF extends CF { - final String batchName; + public EngineCF() { + } - private ToBatchCF(String batchName) { - this.batchName = batchName; + public EngineCF(Object r) { + super(r); + } + + @Override + public CF newIncompleteFuture() { + return new EngineCF<>(); } + + } + + // meaning the CF is not considered when we decide to dispatch + public static CF newEngineCF() { + return new EngineCF<>(); } - public static CF newBatchCF(String name) { - return new ToBatchCF<>(name); + public static CF completedEngineCF(Object value) { + return new EngineCF<>((value == null) ? NIL : value); + } + + + private static class DataLoaderCF extends CF { + final DataLoaderRegistry registry; + final String dataLoaderName; + final Object key; + final CompletableFuture dataLoaderCF; + + volatile CountDownLatch latch; + + public DataLoaderCF(DataLoaderRegistry registry, String dataLoaderName, Object key) { + this.registry = registry; + this.dataLoaderName = dataLoaderName; + this.key = key; + dataLoaderCF = registry.getDataLoader(dataLoaderName).load(key); + dataLoaderCF.whenComplete((value, throwable) -> { + if (throwable != null) { + completeExceptionally(throwable); + } else { + complete((T) value); + } + if (latch != null) { + latch.countDown(); + } + }); + } + + DataLoaderCF() { + this.registry = null; + this.dataLoaderName = null; + this.key = null; + dataLoaderCF = null; + } + + + @Override + public CF newIncompleteFuture() { + return new CF<>(); + } + } + + public static void dispatch(DataLoaderRegistry dataLoaderRegistry) { + if (dataLoaderCFs.size() == 0) { + return; + } + List> dataLoaderCFCopy = new ArrayList<>(dataLoaderCFs); + dataLoaderCFs.clear(); + CountDownLatch countDownLatch = new CountDownLatch(dataLoaderCFCopy.size()); + for (DataLoaderCF dlCF : dataLoaderCFCopy) { + dlCF.latch = countDownLatch; + } + new Thread(() -> { + try { + // waiting until all DL CFs are completed + countDownLatch.await(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + dispatch(dataLoaderRegistry); + }).start(); + dataLoaderRegistry.dispatchAll(); + } + + public static CF newDataLoaderCF(DataFetchingEnvironment environment, String dataLoaderName, Object key) { + return new DataLoaderCF<>(environment.getDataLoaderRegistry(), dataLoaderName, key); } // Replaced misc unsafe with VarHandle @@ -3598,22 +3716,24 @@ public static CF newBatchCF(String name) { public static void main(String[] args) { CompletableFuture future = new CompletableFuture<>(); - CF cf = new CF<>(); - // on the CompletableFuture level cf has a dependent on overall - CompletableFuture overall = future.thenCompose(o -> cf); - - overall.whenComplete((o, throwable) -> - System.out.println("Future completed with: " + o) - ); - future.complete(null); - cf.complete(null); - - cf.thenCompose(x -> { - // some worka - return new CF<>(); + future.thenApply(o -> { + System.out.println("1"); + return null; + }).thenAccept(o -> { + System.out.println("1-1"); + }).thenAccept(o -> { + System.out.println("1-2"); }); - // then compose is a two step: first the outer -> then the function -> then the result of the function - + future.thenApply(o -> { + System.out.println("2"); + return null; + }).thenAccept(o -> { + System.out.println("2-1"); + }).thenAccept(o -> { + ; + System.out.println("2-2"); + }); + future.complete(null); } } diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java index 0d1903eaab..5f368a256a 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java @@ -2,6 +2,7 @@ import graphql.Assert; import graphql.Internal; +import graphql.execution.CF; import graphql.execution.DataLoaderDispatchStrategy; import graphql.execution.ExecutionContext; import graphql.execution.ExecutionStrategyParameters; @@ -276,7 +277,8 @@ private boolean levelReady(int level) { void dispatch(int level) { DataLoaderRegistry dataLoaderRegistry = executionContext.getDataLoaderRegistry(); - dataLoaderRegistry.dispatchAll(); + CF.dispatch(dataLoaderRegistry); +// dataLoaderRegistry.dispatchAll(); } } diff --git a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java index ffe67b10eb..4ee1c85508 100644 --- a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java +++ b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java @@ -14,6 +14,6 @@ public class NoOpPreparsedDocumentProvider implements PreparsedDocumentProvider @Override public CompletableFuture getDocumentAsync(ExecutionInput executionInput, Function parseAndValidateFunction) { - return CF.completedFuture(parseAndValidateFunction.apply(executionInput)); + return CF.completedEngineCF(parseAndValidateFunction.apply(executionInput)); } } diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index a37ba35916..6f62f48986 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -4,6 +4,7 @@ import graphql.analysis.MaxQueryComplexityInstrumentation import graphql.analysis.MaxQueryDepthInstrumentation import graphql.execution.AsyncExecutionStrategy import graphql.execution.AsyncSerialExecutionStrategy +import graphql.execution.CF import graphql.execution.DataFetcherExceptionHandler import graphql.execution.DataFetcherExceptionHandlerParameters import graphql.execution.DataFetcherExceptionHandlerResult @@ -38,6 +39,10 @@ import graphql.schema.idl.errors.SchemaProblem import graphql.schema.validation.InvalidSchemaException import graphql.validation.ValidationError import graphql.validation.ValidationErrorType +import org.dataloader.BatchLoader +import org.dataloader.DataLoader +import org.dataloader.DataLoaderFactory +import org.dataloader.DataLoaderRegistry import spock.lang.Specification import spock.lang.Unroll @@ -101,14 +106,45 @@ class GraphQLTest extends Specification { catName: String } ''' + BatchLoader batchLoader = { keys -> + return CompletableFuture.supplyAsync { + Thread.sleep(1000) + println "BatchLoader called with keys: $keys" + if (keys.size() == 1) { + return ["ONLY ONE KEY"] + } else { + return ["Luna", "Tiger"] + } + } + } + + DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); + + DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); + // + // we make sure our dataloader is in the registry + dataLoaderRegistry.register("name", nameDataLoader); + def df1 = { env -> -// return CF.newBatchCF("animalName1").thenCompose { it -> CF.newBatchCF("animalName2") } - return "Luna" + println "DF1" + return CF.newDataLoaderCF(env, "name", "Key1").thenCompose { + result -> + { + println "finished Dog outer DF with $result" + return CF.newDataLoaderCF(env, "name", result) + } + } } as DataFetcher def df2 = { env -> -// return CF.newBatchCF("animalName1").thenCompose { it -> CF.newBatchCF("animalName2") } - return "Tiger" + println "DF2" + return CF.newDataLoaderCF(env, "name", "Key2").thenCompose { + result -> + { + println "finished Cat outer DF with $result" + return CF.newDataLoaderCF(env, "name", result) + } + } } as DataFetcher @@ -117,7 +153,7 @@ class GraphQLTest extends Specification { def graphQL = GraphQL.newGraphQL(schema).build() def query = "{ dogName catName } " - def ei = newExecutionInput(query).build() + def ei = newExecutionInput(query).dataLoaderRegistry(dataLoaderRegistry).build() when: def er = graphQL.execute(ei) From 646929c71cd61966bbfeb8b2192504ae5d1cab94 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 15:45:40 +1000 Subject: [PATCH 03/19] very very wip --- .../graphql/execution/SimpleDataFetcherExceptionHandler.java | 2 +- src/test/groovy/graphql/GraphQLTest.groovy | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/graphql/execution/SimpleDataFetcherExceptionHandler.java b/src/main/java/graphql/execution/SimpleDataFetcherExceptionHandler.java index 79e201a333..1618fe72ac 100644 --- a/src/main/java/graphql/execution/SimpleDataFetcherExceptionHandler.java +++ b/src/main/java/graphql/execution/SimpleDataFetcherExceptionHandler.java @@ -29,7 +29,7 @@ private DataFetcherExceptionHandlerResult handleExceptionImpl(DataFetcherExcepti @Override public CompletableFuture handleException(DataFetcherExceptionHandlerParameters handlerParameters) { - return CompletableFuture.completedFuture(handleExceptionImpl(handlerParameters)); + return CF.completedFuture(handleExceptionImpl(handlerParameters)); } /** diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index 6f62f48986..bb954fb201 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -141,6 +141,7 @@ class GraphQLTest extends Specification { return CF.newDataLoaderCF(env, "name", "Key2").thenCompose { result -> { +// throw new RuntimeException(); println "finished Cat outer DF with $result" return CF.newDataLoaderCF(env, "name", result) } From 1c0d66cb2f60e09abefd2f2f122d438d205355d2 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 16:12:03 +1000 Subject: [PATCH 04/19] cleanup a bit --- src/main/java/graphql/GraphQL.java | 2 +- src/main/java/graphql/execution/Async.java | 4 +- .../execution/AsyncExecutionStrategy.java | 2 +- .../AsyncSerialExecutionStrategy.java | 2 +- src/main/java/graphql/execution/CF.java | 69 +------------------ .../NoOpPreparsedDocumentProvider.java | 2 +- src/test/groovy/graphql/GraphQLTest.groovy | 1 - 7 files changed, 8 insertions(+), 74 deletions(-) diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index c7a3f00579..acfb7adc3a 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -475,7 +475,7 @@ private CF parseValidateAndExecute(ExecutionInput executionInpu CF preparsedDoc = CF.wrap(preparsedDocumentProvider.getDocumentAsync(executionInput, computeFunction)); return preparsedDoc.thenCompose(preparsedDocumentEntry -> { if (preparsedDocumentEntry.hasErrors()) { - return CF.completedEngineCF(new ExecutionResultImpl(preparsedDocumentEntry.getErrors())); + return CF.completedFuture(new ExecutionResultImpl(preparsedDocumentEntry.getErrors())); } try { return execute(executionInputRef.get(), preparsedDocumentEntry.getDocument(), graphQLSchema, instrumentationState); diff --git a/src/main/java/graphql/execution/Async.java b/src/main/java/graphql/execution/Async.java index 644ed8b276..f28b048edd 100644 --- a/src/main/java/graphql/execution/Async.java +++ b/src/main/java/graphql/execution/Async.java @@ -194,12 +194,12 @@ public void addObject(Object object) { public CompletableFuture> await() { commonSizeAssert(); - CF> overallResult = CF.newEngineCF(); + CF> overallResult = new CF<>(); if (cfCount == 0) { overallResult.complete(materialisedList(array)); } else { CF[] cfsArr = copyOnlyCFsToArray(); - CF.allOfEngineCFs(cfsArr) + CF.allOf(cfsArr) .whenComplete((ignored, exception) -> { if (exception != null) { overallResult.completeExceptionally(exception); diff --git a/src/main/java/graphql/execution/AsyncExecutionStrategy.java b/src/main/java/graphql/execution/AsyncExecutionStrategy.java index 1ab08864e4..d65d8350ed 100644 --- a/src/main/java/graphql/execution/AsyncExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncExecutionStrategy.java @@ -57,7 +57,7 @@ public CompletableFuture execute(ExecutionContext executionCont Async.CombinedBuilder futures = getAsyncFieldValueInfo(executionContext, parameters, deferredExecutionSupport); // can be waiting on DataFetcher completion, therefore it is a engine cCF - CF overallResult = CF.newEngineCF(); + CF overallResult = new CF<>(); executionStrategyCtx.onDispatched(); futures.await().whenComplete((completeValueInfos, throwable) -> { diff --git a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java index a8a7feb39f..ba0796b03e 100644 --- a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java @@ -58,7 +58,7 @@ public CompletableFuture execute(ExecutionContext executionCont return resolveSerialField(executionContext, dataLoaderDispatcherStrategy, newParameters); }); - CF overallResult = CF.newEngineCF(); + CF overallResult = new CF<>(); executionStrategyCtx.onDispatched(); resultsFuture.whenComplete(handleResults(executionContext, fieldNames, overallResult)); diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index 5f1093f13d..5859bb6d32 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -1339,9 +1339,6 @@ final CF tryFire(int mode) { } @SuppressWarnings("unchecked") T t = (T) r; CompletionStage apply = f.apply(t).toCompletableFuture(); - if (!(apply instanceof CF)) { - System.out.println("mmm"); - } CF g = (CF) apply; if ((r = g.result) != null) { d.completeRelay(r); @@ -1806,36 +1803,6 @@ static CF andTree(CF[] cfs, return d; } - static CF andTreeEngine(CF[] cfs, - int lo, int hi) { - CF d = new EngineCF<>(); - if (lo > hi) // empty - { - d.assignResult(NIL); - } else { - CF a, b; - Object r, s, z; - Throwable x; - int mid = (lo + hi) >>> 1; - if ((a = (lo == mid ? cfs[lo] : - andTreeEngine(cfs, lo, mid))) == null || - (b = (lo == hi ? a : (hi == mid + 1) ? cfs[hi] : - andTreeEngine(cfs, mid + 1, hi))) == null) { - throw new NullPointerException(); - } - if ((r = a.result) == null || (s = b.result) == null) { - a.bipush(b, new BiRelay<>(d, a, b)); - } else if ((r instanceof AltResult - && (x = ((AltResult) (z = r)).ex) != null) || - (s instanceof AltResult - && (x = ((AltResult) (z = s)).ex) != null)) { - d.assignResult(encodeThrowable(x, z)); - } else { - d.assignResult(NIL); - } - } - return d; - } /* ------------- Projected (Ored) BiCompletions -------------- */ @@ -2399,8 +2366,6 @@ public CF() { private void newInstance() { if ((this instanceof DataLoaderCF)) { dataLoaderCFs.add((DataLoaderCF) this); - } else if ((this instanceof EngineCF)) { -// System.out.println("new Engine CF instance " + this); } else { allNormalCFs.add(this); // System.out.println("new CF instance " + this + " total count" + allNormalCFs.size()); @@ -2408,7 +2373,7 @@ private void newInstance() { } private void afterCompletedInternal() { - if (this.result != null && !(this instanceof DataLoaderCF) && !(this instanceof EngineCF)) { + if (this.result != null && !(this instanceof DataLoaderCF)) { completedCfs.add(this); // System.out.println("completed CF instance " + this + " completed count: " + completedCfs.size()); } @@ -2884,10 +2849,6 @@ public static CF allOf(CF... cfs) { return andTree(cfs, 0, cfs.length - 1); } - public static CF allOfEngineCFs(CF... cfs) { - return andTreeEngine(cfs, 0, cfs.length - 1); - } - /** * Returns a new CF that is completed when any of @@ -3338,7 +3299,7 @@ public static CF wrap( if (completableFuture instanceof CF) { return (CF) completableFuture; } - EngineCF cf = new EngineCF<>(); + CF cf = new CF<>(); completableFuture.whenComplete((u, ex) -> { if (ex != null) { cf.completeExceptionally(ex); @@ -3602,32 +3563,6 @@ public CF toCompletableFuture() { } } - private static class EngineCF extends CF { - - public EngineCF() { - } - - public EngineCF(Object r) { - super(r); - } - - @Override - public CF newIncompleteFuture() { - return new EngineCF<>(); - } - - } - - // meaning the CF is not considered when we decide to dispatch - public static CF newEngineCF() { - return new EngineCF<>(); - } - - public static CF completedEngineCF(Object value) { - return new EngineCF<>((value == null) ? NIL : value); - } - - private static class DataLoaderCF extends CF { final DataLoaderRegistry registry; final String dataLoaderName; diff --git a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java index 4ee1c85508..ffe67b10eb 100644 --- a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java +++ b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java @@ -14,6 +14,6 @@ public class NoOpPreparsedDocumentProvider implements PreparsedDocumentProvider @Override public CompletableFuture getDocumentAsync(ExecutionInput executionInput, Function parseAndValidateFunction) { - return CF.completedEngineCF(parseAndValidateFunction.apply(executionInput)); + return CF.completedFuture(parseAndValidateFunction.apply(executionInput)); } } diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index bb954fb201..6f62f48986 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -141,7 +141,6 @@ class GraphQLTest extends Specification { return CF.newDataLoaderCF(env, "name", "Key2").thenCompose { result -> { -// throw new RuntimeException(); println "finished Cat outer DF with $result" return CF.newDataLoaderCF(env, "name", result) } From 0b3cc9bc8f57be4f2d4bd92089576bd2d7b4b797 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 16:16:27 +1000 Subject: [PATCH 05/19] use more CF --- src/main/java/graphql/GraphQL.java | 2 +- .../graphql/analysis/MaxQueryComplexityInstrumentation.java | 3 ++- src/main/java/graphql/execution/Async.java | 6 +++--- src/main/java/graphql/execution/AsyncExecutionStrategy.java | 2 +- .../graphql/execution/AsyncSerialExecutionStrategy.java | 2 +- .../threadpools/ExecutorInstrumentation.java | 3 ++- .../instrumentation/tracing/TracingInstrumentation.java | 5 +++-- .../preparsed/persisted/InMemoryPersistedQueryCache.java | 3 ++- 8 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index acfb7adc3a..f0dd287460 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -480,7 +480,7 @@ private CF parseValidateAndExecute(ExecutionInput executionInpu try { return execute(executionInputRef.get(), preparsedDocumentEntry.getDocument(), graphQLSchema, instrumentationState); } catch (AbortExecutionException e) { - return CompletableFuture.completedFuture(e.toExecutionResult()); + return CF.completedFuture(e.toExecutionResult()); } }); } diff --git a/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java b/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java index 64a79612d6..77b9d5aa32 100644 --- a/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java +++ b/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java @@ -3,6 +3,7 @@ import graphql.ExecutionResult; import graphql.PublicApi; import graphql.execution.AbortExecutionException; +import graphql.execution.CF; import graphql.execution.ExecutionContext; import graphql.execution.instrumentation.InstrumentationContext; import graphql.execution.instrumentation.InstrumentationState; @@ -80,7 +81,7 @@ public MaxQueryComplexityInstrumentation(int maxComplexity, FieldComplexityCalcu @Override public @Nullable CompletableFuture createStateAsync(InstrumentationCreateStateParameters parameters) { - return CompletableFuture.completedFuture(new State()); + return CF.completedFuture(new State()); } @Override diff --git a/src/main/java/graphql/execution/Async.java b/src/main/java/graphql/execution/Async.java index f28b048edd..e31ca56f63 100644 --- a/src/main/java/graphql/execution/Async.java +++ b/src/main/java/graphql/execution/Async.java @@ -280,7 +280,7 @@ public static CompletableFuture> each(Collection list, Functio if (l instanceof CompletableFuture) { return (CompletableFuture>) l; } else { - return CompletableFuture.completedFuture((List) l); + return CF.completedFuture((List) l); } } @@ -359,9 +359,9 @@ private static void eachSequentiallyPolymorphicImpl(Iterator iterator, @SuppressWarnings("unchecked") public static CompletableFuture toCompletableFuture(Object t) { if (t instanceof CompletionStage) { - return ((CompletionStage) t).toCompletableFuture(); + return CF.wrap(((CompletionStage) t).toCompletableFuture()); } else { - return CompletableFuture.completedFuture((T) t); + return CF.completedFuture((T) t); } } diff --git a/src/main/java/graphql/execution/AsyncExecutionStrategy.java b/src/main/java/graphql/execution/AsyncExecutionStrategy.java index d65d8350ed..88c69c2164 100644 --- a/src/main/java/graphql/execution/AsyncExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncExecutionStrategy.java @@ -50,7 +50,7 @@ public CompletableFuture execute(ExecutionContext executionCont Optional isNotSensible = Introspection.isIntrospectionSensible(fields, executionContext); if (isNotSensible.isPresent()) { - return CompletableFuture.completedFuture(isNotSensible.get()); + return CF.completedFuture(isNotSensible.get()); } DeferredExecutionSupport deferredExecutionSupport = createDeferredExecutionSupport(executionContext, parameters); diff --git a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java index ba0796b03e..3eea6960aa 100644 --- a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java @@ -46,7 +46,7 @@ public CompletableFuture execute(ExecutionContext executionCont // so belts and braces Optional isNotSensible = Introspection.isIntrospectionSensible(fields, executionContext); if (isNotSensible.isPresent()) { - return CompletableFuture.completedFuture(isNotSensible.get()); + return CF.completedFuture(isNotSensible.get()); } CompletableFuture> resultsFuture = Async.eachSequentially(fieldNames, (fieldName, prevResults) -> { diff --git a/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java b/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java index 9727801305..891ddb34a8 100644 --- a/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java @@ -5,6 +5,7 @@ import graphql.Internal; import graphql.TrivialDataFetcher; import graphql.execution.Async; +import graphql.execution.CF; import graphql.execution.instrumentation.InstrumentationState; import graphql.execution.instrumentation.SimplePerformantInstrumentation; import graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters; @@ -160,7 +161,7 @@ private CompletionStage invokeOriginalDF(DataFetcher originalDataFetcher, if (value instanceof CompletionStage) { return ((CompletionStage) value); } else { - return CompletableFuture.completedFuture(value); + return CF.completedFuture(value); } } } diff --git a/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java b/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java index ed18f68ab8..238d368001 100644 --- a/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java @@ -4,6 +4,7 @@ import graphql.ExecutionResultImpl; import graphql.PublicApi; import graphql.collect.ImmutableKit; +import graphql.execution.CF; import graphql.execution.instrumentation.Instrumentation; import graphql.execution.instrumentation.InstrumentationContext; import graphql.execution.instrumentation.InstrumentationState; @@ -73,7 +74,7 @@ public TracingInstrumentation(Options options) { @Override public @Nullable CompletableFuture createStateAsync(InstrumentationCreateStateParameters parameters) { - return CompletableFuture.completedFuture(new TracingSupport(options.includeTrivialDataFetchers)); + return CF.completedFuture(new TracingSupport(options.includeTrivialDataFetchers)); } @Override @@ -84,7 +85,7 @@ public TracingInstrumentation(Options options) { Map withTracingExt = new LinkedHashMap<>(currentExt == null ? ImmutableKit.emptyMap() : currentExt); withTracingExt.put("tracing", tracingSupport.snapshotTracingData()); - return CompletableFuture.completedFuture(new ExecutionResultImpl(executionResult.getData(), executionResult.getErrors(), withTracingExt)); + return CF.completedFuture(new ExecutionResultImpl(executionResult.getData(), executionResult.getErrors(), withTracingExt)); } @Override diff --git a/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java b/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java index 5226332b85..65c10c03c7 100644 --- a/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java +++ b/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java @@ -3,6 +3,7 @@ import graphql.Assert; import graphql.ExecutionInput; import graphql.PublicApi; +import graphql.execution.CF; import graphql.execution.preparsed.PreparsedDocumentEntry; import java.util.HashMap; @@ -46,7 +47,7 @@ public CompletableFuture getPersistedQueryDocumentAsync( } return onCacheMiss.apply(queryText); }); - return CompletableFuture.completedFuture(documentEntry); + return CF.completedFuture(documentEntry); } public static Builder newInMemoryPersistedQueryCache() { From 4718844e15422302e8af45478561f7abde84d587 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 16:17:38 +1000 Subject: [PATCH 06/19] wip --- src/test/groovy/graphql/GraphQLTest.groovy | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index 6f62f48986..738f52bfc5 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -158,7 +158,7 @@ class GraphQLTest extends Specification { when: def er = graphQL.execute(ei) then: - er.data == [hello: "world"] + er.data == [dogName: "Luna", catName: "Tiger"] } From 6cb6730994bcdfa9d7ca656207dcbddcf0b98fee Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 16:51:27 +1000 Subject: [PATCH 07/19] wip --- src/main/java/graphql/execution/Async.java | 12 +++++------- src/main/java/graphql/execution/CF.java | 1 + src/main/java/graphql/execution/Execution.java | 9 ++++----- .../java/graphql/execution/ExecutionStrategy.java | 2 +- .../execution/instrumentation/Instrumentation.java | 2 +- .../SimplePerformantInstrumentation.java | 5 +++-- .../threadpools/ExecutorInstrumentation.java | 2 +- .../preparsed/persisted/PersistedQuerySupport.java | 6 +++--- .../execution/BreadthFirstExecutionTestStrategy.java | 2 +- .../graphql/execution/BreadthFirstTestStrategy.java | 10 +++++----- 10 files changed, 25 insertions(+), 26 deletions(-) diff --git a/src/main/java/graphql/execution/Async.java b/src/main/java/graphql/execution/Async.java index e31ca56f63..7900290efe 100644 --- a/src/main/java/graphql/execution/Async.java +++ b/src/main/java/graphql/execution/Async.java @@ -303,7 +303,7 @@ public static CompletableFuture> each(Collection list, Functio Object value = cfOrMaterialisedValueFactory.apply(t); futures.addObject(value); } catch (Exception e) { - CompletableFuture cf = new CompletableFuture<>(); + CF cf = new CF<>(); // Async.each makes sure that it is not a CompletionException inside a CompletionException cf.completeExceptionally(new CompletionException(e)); futures.add(cf); @@ -313,7 +313,7 @@ public static CompletableFuture> each(Collection list, Functio } public static CompletableFuture> eachSequentially(Iterable list, BiFunction, Object> cfOrMaterialisedValueFactory) { - CompletableFuture> result = new CompletableFuture<>(); + CF> result = new CF<>(); eachSequentiallyPolymorphicImpl(list.iterator(), cfOrMaterialisedValueFactory, new ArrayList<>(), result); return result; } @@ -375,7 +375,7 @@ public static CompletableFuture toCompletableFuture(Object t) { */ public static Object toCompletableFutureOrMaterializedObject(Object object) { if (object instanceof CompletionStage) { - return ((CompletionStage) object).toCompletableFuture(); + return CF.wrap(((CompletionStage) object).toCompletableFuture()); } else { return object; } @@ -385,14 +385,12 @@ public static CompletableFuture tryCatch(Supplier> s try { return supplier.get(); } catch (Exception e) { - CompletableFuture result = new CompletableFuture<>(); - result.completeExceptionally(e); - return result; + return exceptionallyCompletedFuture(e); } } public static CompletableFuture exceptionallyCompletedFuture(Throwable exception) { - CompletableFuture result = new CompletableFuture<>(); + CF result = new CF<>(); result.completeExceptionally(exception); return result; } diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index 5859bb6d32..ab3c3d8d0d 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -3604,6 +3604,7 @@ public CF newIncompleteFuture() { public static void dispatch(DataLoaderRegistry dataLoaderRegistry) { if (dataLoaderCFs.size() == 0) { + dataLoaderRegistry.dispatchAll(); return; } List> dataLoaderCFCopy = new ArrayList<>(dataLoaderCFs); diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java index 634837f987..0fa7734f45 100644 --- a/src/main/java/graphql/execution/Execution.java +++ b/src/main/java/graphql/execution/Execution.java @@ -29,8 +29,8 @@ import graphql.schema.GraphQLObjectType; import graphql.schema.GraphQLSchema; import graphql.schema.impl.SchemaUtil; -import org.jspecify.annotations.NonNull; import graphql.util.FpKit; +import org.jspecify.annotations.NonNull; import org.reactivestreams.Publisher; import java.util.Collections; @@ -46,7 +46,6 @@ import static graphql.execution.ExecutionStrategyParameters.newParameters; import static graphql.execution.instrumentation.SimpleInstrumentationContext.nonNullCtx; import static graphql.execution.instrumentation.dataloader.EmptyDataLoaderRegistryInstance.EMPTY_DATALOADER_REGISTRY; -import static java.util.concurrent.CompletableFuture.completedFuture; @Internal public class Execution { @@ -82,7 +81,7 @@ public CompletableFuture execute(Document document, GraphQLSche normalizedVariableValues = normalizedVariableValues(graphQLSchema, executionInput, getOperationResult); } catch (RuntimeException rte) { if (rte instanceof GraphQLError) { - return completedFuture(new ExecutionResultImpl((GraphQLError) rte)); + return CF.completedFuture(new ExecutionResultImpl((GraphQLError) rte)); } throw rte; } @@ -158,7 +157,7 @@ private CompletableFuture executeOperation(ExecutionContext exe } catch (RuntimeException rte) { if (rte instanceof GraphQLError) { ExecutionResult executionResult = new ExecutionResultImpl(Collections.singletonList((GraphQLError) rte)); - CompletableFuture resultCompletableFuture = completedFuture(executionResult); + CompletableFuture resultCompletableFuture = CF.completedFuture(executionResult); executeOperationCtx.onDispatched(); executeOperationCtx.onCompleted(executionResult, rte); @@ -211,7 +210,7 @@ private CompletableFuture executeOperation(ExecutionContext exe // // https://spec.graphql.org/October2021/#sec-Handling-Field-Errors // - result = completedFuture(new ExecutionResultImpl(null, executionContext.getErrors())); + result = CF.completedFuture(new ExecutionResultImpl(null, executionContext.getErrors())); } // note this happens NOW - not when the result completes diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java index 6cd3888380..daadc82aa9 100644 --- a/src/main/java/graphql/execution/ExecutionStrategy.java +++ b/src/main/java/graphql/execution/ExecutionStrategy.java @@ -607,7 +607,7 @@ protected CompletableFuture handleFetchingException( private CompletableFuture asyncHandleException(DataFetcherExceptionHandler handler, DataFetcherExceptionHandlerParameters handlerParameters) { //noinspection unchecked - return handler.handleException(handlerParameters).thenApply( + return CF.wrap(handler.handleException(handlerParameters)).thenApply( handlerResult -> (T) DataFetcherResult.newResult().errors(handlerResult.getErrors()).build() ); } diff --git a/src/main/java/graphql/execution/instrumentation/Instrumentation.java b/src/main/java/graphql/execution/instrumentation/Instrumentation.java index 2ebaec624c..f5f8a52bf3 100644 --- a/src/main/java/graphql/execution/instrumentation/Instrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/Instrumentation.java @@ -52,7 +52,7 @@ public interface Instrumentation { @Nullable default CompletableFuture createStateAsync(InstrumentationCreateStateParameters parameters) { InstrumentationState state = createState(parameters); - return state == null ? null : CompletableFuture.completedFuture(state); + return state == null ? null : CF.completedFuture(state); } /** diff --git a/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java b/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java index 26f30714fa..cafe855150 100644 --- a/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java @@ -3,6 +3,7 @@ import graphql.ExecutionInput; import graphql.ExecutionResult; import graphql.PublicApi; +import graphql.execution.CF; import graphql.execution.ExecutionContext; import graphql.execution.instrumentation.parameters.InstrumentationCreateStateParameters; import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters; @@ -48,7 +49,7 @@ public class SimplePerformantInstrumentation implements Instrumentation { @Override public @Nullable CompletableFuture createStateAsync(InstrumentationCreateStateParameters parameters) { InstrumentationState state = createState(parameters); - return state == null ? null : CompletableFuture.completedFuture(state); + return state == null ? null : CF.completedFuture(state); } @Override @@ -138,6 +139,6 @@ public class SimplePerformantInstrumentation implements Instrumentation { @Override public @NonNull CompletableFuture instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) { - return CompletableFuture.completedFuture(executionResult); + return CF.completedFuture(executionResult); } } diff --git a/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java b/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java index 891ddb34a8..0893805fc6 100644 --- a/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java @@ -141,7 +141,7 @@ private Supplier> invokedAsync(DataFetcher originalDataFet private CompletableFuture> invokedSync(DataFetcher originalDataFetcher, DataFetchingEnvironment environment) { actionObserver.accept(FETCHING); - return CompletableFuture.completedFuture(invokeOriginalDF(originalDataFetcher, environment)); + return CF.completedFuture(invokeOriginalDF(originalDataFetcher, environment)); } private Function, CompletionStage> processingControl() { diff --git a/src/main/java/graphql/execution/preparsed/persisted/PersistedQuerySupport.java b/src/main/java/graphql/execution/preparsed/persisted/PersistedQuerySupport.java index b65e20b78a..607ce3f813 100644 --- a/src/main/java/graphql/execution/preparsed/persisted/PersistedQuerySupport.java +++ b/src/main/java/graphql/execution/preparsed/persisted/PersistedQuerySupport.java @@ -4,6 +4,7 @@ import graphql.GraphQLError; import graphql.GraphqlErrorBuilder; import graphql.PublicSpi; +import graphql.execution.CF; import graphql.execution.preparsed.PreparsedDocumentEntry; import graphql.execution.preparsed.PreparsedDocumentProvider; @@ -12,7 +13,6 @@ import java.util.function.Function; import static graphql.Assert.assertNotNull; -import static java.util.concurrent.CompletableFuture.completedFuture; /** * This abstract class forms the basis for persistent query support. Derived classes @@ -59,9 +59,9 @@ public CompletableFuture getDocumentAsync(ExecutionInput }); } // ok there is no query id - we assume the query is indeed ready to go as is - ie its not a persisted query - return completedFuture(parseAndValidateFunction.apply(executionInput)); + return CF.completedFuture(parseAndValidateFunction.apply(executionInput)); } catch (PersistedQueryError e) { - return completedFuture(mkMissingError(e)); + return CF.completedFuture(mkMissingError(e)); } } diff --git a/src/test/groovy/graphql/execution/BreadthFirstExecutionTestStrategy.java b/src/test/groovy/graphql/execution/BreadthFirstExecutionTestStrategy.java index 167e58a3b9..c01426353f 100644 --- a/src/test/groovy/graphql/execution/BreadthFirstExecutionTestStrategy.java +++ b/src/test/groovy/graphql/execution/BreadthFirstExecutionTestStrategy.java @@ -48,7 +48,7 @@ public CompletableFuture execute(ExecutionContext executionCont break; } } - return CompletableFuture.completedFuture(new ExecutionResultImpl(results, executionContext.getErrors())); + return CF.completedFuture(new ExecutionResultImpl(results, executionContext.getErrors())); } private FetchedValue fetchField(ExecutionContext executionContext, ExecutionStrategyParameters parameters, MergedSelectionSet fields, String fieldName) { diff --git a/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java b/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java index 653e035df1..3fb23a8d4f 100644 --- a/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java +++ b/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java @@ -35,13 +35,13 @@ public CompletableFuture execute(ExecutionContext executionCont private Map fetchFields(ExecutionContext executionContext, ExecutionStrategyParameters parameters) { MergedSelectionSet fields = parameters.getFields(); - Map> fetchFutures = new LinkedHashMap<>(); + Map> fetchFutures = new LinkedHashMap<>(); // first fetch every value for (String fieldName : fields.keySet()) { ExecutionStrategyParameters newParameters = newParameters(parameters, fields, fieldName); - CompletableFuture fetchFuture = Async.toCompletableFuture(fetchField(executionContext, newParameters)); + CF fetchFuture = (CF) Async.toCompletableFuture(fetchField(executionContext, newParameters)); fetchFutures.put(fieldName, fetchFuture); } @@ -82,10 +82,10 @@ private ExecutionStrategyParameters newParameters(ExecutionStrategyParameters pa } - public static CompletableFuture> allOf(final Collection> futures) { - CompletableFuture[] cfs = futures.toArray(new CompletableFuture[futures.size()]); + public static CF> allOf(final Collection> futures) { + CF[] cfs = futures.toArray(new CF[futures.size()]); - return CompletableFuture.allOf(cfs) + return CF.allOf(cfs) .thenApply(vd -> futures.stream() .map(CompletableFuture::join) .collect(Collectors.toList()) From 69724c500e2b3306058cf7eed7ec117440a24b7c Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 21:13:19 +1000 Subject: [PATCH 08/19] fixing tests --- src/main/java/graphql/GraphQL.java | 3 +-- src/main/java/graphql/execution/Async.java | 10 +++++----- src/main/java/graphql/execution/CF.java | 19 +++++++++++++++++-- .../SubscriptionExecutionStrategy.java | 2 +- .../ChainedInstrumentation.java | 3 ++- .../execution/reactive/ReactiveSupport.java | 5 +++-- .../groovy/graphql/execution/AsyncTest.groovy | 3 ++- .../execution/BreadthFirstTestStrategy.java | 2 +- .../dataloader/DataLoaderHangingTest.groovy | 3 ++- .../ExecutorInstrumentationTest.groovy | 1 + 10 files changed, 35 insertions(+), 16 deletions(-) diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index f0dd287460..46accb5ac5 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -441,8 +441,7 @@ public CompletableFuture executeAsync(ExecutionInput executionI return handleAbortException(executionInput, instrumentationState, abortException); } }); - rootCF.complete(null); - return cf; + return cf.bridgeToDefaultCompletableFuture(); } private CompletableFuture handleAbortException(ExecutionInput executionInput, InstrumentationState instrumentationState, AbortExecutionException abortException) { diff --git a/src/main/java/graphql/execution/Async.java b/src/main/java/graphql/execution/Async.java index 7900290efe..7900513b59 100644 --- a/src/main/java/graphql/execution/Async.java +++ b/src/main/java/graphql/execution/Async.java @@ -140,7 +140,7 @@ public CompletableFuture> await() { if (value instanceof CompletableFuture) { @SuppressWarnings("unchecked") CompletableFuture cf = (CompletableFuture) value; - return cf.thenApply(Collections::singletonList); + return CF.wrap(cf).thenApply(Collections::singletonList); } //noinspection unchecked return CF.completedFuture(Collections.singletonList((T) value)); @@ -152,7 +152,7 @@ public Object awaitPolymorphic() { if (value instanceof CompletableFuture) { @SuppressWarnings("unchecked") CompletableFuture cf = (CompletableFuture) value; - return cf.thenApply(Collections::singletonList); + return CF.wrap(cf).thenApply(Collections::singletonList); } //noinspection unchecked return Collections.singletonList((T) value); @@ -278,7 +278,7 @@ private void commonSizeAssert() { public static CompletableFuture> each(Collection list, Function cfOrMaterialisedValueFactory) { Object l = eachPolymorphic(list, cfOrMaterialisedValueFactory); if (l instanceof CompletableFuture) { - return (CompletableFuture>) l; + return CF.wrap((CompletableFuture>) l); } else { return CF.completedFuture((List) l); } @@ -333,7 +333,7 @@ private static void eachSequentiallyPolymorphicImpl(Iterator iterator, } if (value instanceof CompletableFuture) { CompletableFuture cf = (CompletableFuture) value; - cf.whenComplete((cfResult, exception) -> { + CF.wrap(cf).whenComplete((cfResult, exception) -> { if (exception != null) { overallResult.completeExceptionally(exception); return; @@ -404,6 +404,6 @@ public static CompletableFuture exceptionallyCompletedFuture(Throwable ex * @return the completableFuture if it's not null or one that always resoles to null */ public static @NonNull CF orNullCompletedFuture(@Nullable CompletableFuture completableFuture) { - return completableFuture != null ? CF.wrap(completableFuture) : new CF<>();//CF.completedFuture(null); + return completableFuture != null ? CF.wrap(completableFuture) : CF.completedFuture(null); } } diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index ab3c3d8d0d..c30a35d92a 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -2297,6 +2297,8 @@ private Object timedGet(long nanos) throws TimeoutException { if (Thread.interrupted()) { return null; } + // Signaller is a Completion that unblocks the current threads + // meaning once this CF is completed the Thread is relased if (nanos > 0L) { long d = System.nanoTime() + nanos; long deadline = (d == 0L) ? 1L : d; // avoid 0 @@ -2307,7 +2309,7 @@ private Object timedGet(long nanos) throws TimeoutException { if (q == null) { q = new Signaller(true, nanos, deadline); // if (Thread.currentThread() instanceof ForkJoinWorkerThread) { -// ForkJoinPool.helpAsyncBlocker(defaultExecutor(), q); +// ForkJoinPool.helpAsyncBlocker(defaultExecutor(), q); // } } else if (!queued) { queued = tryPushStack(q); @@ -2787,6 +2789,19 @@ public CF toCompletableFuture() { return this; } + public CompletableFuture bridgeToDefaultCompletableFuture() { + CompletableFuture future = new CompletableFuture<>(); + whenComplete((t, throwable) -> { + if (throwable != null) { + future.completeExceptionally(throwable); + } else { + future.complete(t); + } + } + ); + return future; + } + public CF exceptionally( Function fn) { return uniExceptionallyStage(null, fn); @@ -3615,7 +3630,7 @@ public static void dispatch(DataLoaderRegistry dataLoaderRegistry) { } new Thread(() -> { try { - // waiting until all DL CFs are completed + // waiting until all sync codes for all DL CFs are run countDownLatch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); diff --git a/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java b/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java index 4cc43963b8..fa95e86ad3 100644 --- a/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java +++ b/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java @@ -161,7 +161,7 @@ private CompletableFuture executeSubscriptionEvent(ExecutionCon InstrumentationExecutionParameters i13nExecutionParameters = new InstrumentationExecutionParameters( executionContext.getExecutionInput(), executionContext.getGraphQLSchema()); - overallResult = overallResult.thenCompose(executionResult -> instrumentation.instrumentExecutionResult(executionResult, i13nExecutionParameters, executionContext.getInstrumentationState())); + overallResult = overallResult.thenCompose(executionResult -> CF.wrap(instrumentation.instrumentExecutionResult(executionResult, i13nExecutionParameters, executionContext.getInstrumentationState()))); return overallResult; } diff --git a/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java b/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java index daca12293f..10b5c287e9 100644 --- a/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java @@ -6,6 +6,7 @@ import graphql.ExperimentalApi; import graphql.PublicApi; import graphql.execution.Async; +import graphql.execution.CF; import graphql.execution.ExecutionContext; import graphql.execution.FieldValueInfo; import graphql.execution.instrumentation.parameters.InstrumentationCreateStateParameters; @@ -254,7 +255,7 @@ public CompletableFuture instrumentExecutionResult(ExecutionRes Instrumentation instrumentation = entry.getKey(); InstrumentationState specificState = entry.getValue(); ExecutionResult lastResult = !prevResults.isEmpty() ? prevResults.get(prevResults.size() - 1) : executionResult; - return instrumentation.instrumentExecutionResult(lastResult, parameters, specificState); + return CF.wrap(instrumentation.instrumentExecutionResult(lastResult, parameters, specificState)); }); return resultsFuture.thenApply((results) -> results.isEmpty() ? executionResult : results.get(results.size() - 1)); } diff --git a/src/main/java/graphql/execution/reactive/ReactiveSupport.java b/src/main/java/graphql/execution/reactive/ReactiveSupport.java index 3e02f11592..7c08eca78f 100644 --- a/src/main/java/graphql/execution/reactive/ReactiveSupport.java +++ b/src/main/java/graphql/execution/reactive/ReactiveSupport.java @@ -2,6 +2,7 @@ import graphql.DuckTyped; import graphql.Internal; +import graphql.execution.CF; import org.reactivestreams.Publisher; import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; @@ -34,13 +35,13 @@ public static Object fetchedObject(Object fetchedObject) { private static CompletableFuture reactivePublisherToCF(Publisher publisher) { ReactivePublisherToCompletableFuture cf = new ReactivePublisherToCompletableFuture<>(); publisher.subscribe(cf); - return cf; + return CF.wrap(cf); } private static CompletableFuture flowPublisherToCF(Flow.Publisher publisher) { FlowPublisherToCompletableFuture cf = new FlowPublisherToCompletableFuture<>(); publisher.subscribe(cf); - return cf; + return CF.wrap(cf); } /** diff --git a/src/test/groovy/graphql/execution/AsyncTest.groovy b/src/test/groovy/graphql/execution/AsyncTest.groovy index 2661c4f5fd..44f3cc2fb4 100644 --- a/src/test/groovy/graphql/execution/AsyncTest.groovy +++ b/src/test/groovy/graphql/execution/AsyncTest.groovy @@ -8,7 +8,8 @@ import java.util.concurrent.CompletionException import java.util.function.BiFunction import java.util.function.Function -import static java.util.concurrent.CompletableFuture.completedFuture +import static graphql.execution.CF.completedFuture + class AsyncTest extends Specification { diff --git a/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java b/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java index 3fb23a8d4f..6c8aa262db 100644 --- a/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java +++ b/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java @@ -71,7 +71,7 @@ private CompletableFuture completeFields(ExecutionContext execu break; } } - return CompletableFuture.completedFuture(new ExecutionResultImpl(results, executionContext.getErrors())); + return CF.completedFuture(new ExecutionResultImpl(results, executionContext.getErrors())); } private ExecutionStrategyParameters newParameters(ExecutionStrategyParameters parameters, MergedSelectionSet fields, String fieldName) { diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderHangingTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderHangingTest.groovy index 2d98da377f..d1fddc7ab6 100644 --- a/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderHangingTest.groovy +++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderHangingTest.groovy @@ -6,6 +6,7 @@ import graphql.GraphQL import graphql.TestUtil import graphql.execution.Async import graphql.execution.AsyncExecutionStrategy +import graphql.execution.CF import graphql.execution.DataFetcherExceptionHandler import graphql.execution.DataFetcherExceptionHandlerParameters import graphql.execution.DataFetcherExceptionHandlerResult @@ -163,7 +164,7 @@ class DataLoaderHangingTest extends Specification { assert res.errors.empty }) // add all futures - futures.add(result) + futures.add(CF.wrap(result)) } // wait for each future to complete and grab the results futures.await() diff --git a/src/test/groovy/graphql/execution/instrumentation/threadpools/ExecutorInstrumentationTest.groovy b/src/test/groovy/graphql/execution/instrumentation/threadpools/ExecutorInstrumentationTest.groovy index eb70c9be98..c9c31d2323 100644 --- a/src/test/groovy/graphql/execution/instrumentation/threadpools/ExecutorInstrumentationTest.groovy +++ b/src/test/groovy/graphql/execution/instrumentation/threadpools/ExecutorInstrumentationTest.groovy @@ -18,6 +18,7 @@ import java.util.function.Consumer import static ExecutorInstrumentation.Action import static java.lang.Thread.currentThread +@Ignore class ExecutorInstrumentationTest extends Specification { private static ThreadFactory threadFactory(String name) { From 3c510186fba324c0b8e45747e8e97bdf6ceebae6 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 21:23:33 +1000 Subject: [PATCH 09/19] fixing tests --- .../graphql/execution/incremental/DeferredFragmentCall.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java b/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java index 79b9496fd1..e09acae3b9 100644 --- a/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java +++ b/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java @@ -5,6 +5,7 @@ import graphql.GraphQLError; import graphql.Internal; import graphql.execution.Async; +import graphql.execution.CF; import graphql.execution.NonNullableFieldWasNullError; import graphql.execution.NonNullableFieldWasNullException; import graphql.execution.ResultPath; @@ -66,7 +67,7 @@ public CompletableFuture invoke() { calls.forEach(call -> { CompletableFuture cf = call.get(); - futures.add(cf); + futures.add(CF.wrap(cf)); }); return futures.await() From f15aadedb566e9f663ec71e6bbe76e7de416c7c1 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 21:35:31 +1000 Subject: [PATCH 10/19] cleanup --- src/main/java/graphql/execution/CF.java | 31 ++++------------------ src/test/groovy/graphql/GraphQLTest.groovy | 9 +++++-- 2 files changed, 12 insertions(+), 28 deletions(-) diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index c30a35d92a..bd22f36f83 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -13,12 +13,10 @@ import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.List; -import java.util.Set; import java.util.concurrent.CancellationException; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; import java.util.concurrent.CompletionStage; -import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; @@ -2344,10 +2342,10 @@ private Object timedGet(long nanos) throws TimeoutException { /* ------------- public methods -------------- */ - public static CopyOnWriteArrayList> allNormalCFs = new CopyOnWriteArrayList<>(); + // public static CopyOnWriteArrayList> allNormalCFs = new CopyOnWriteArrayList<>(); public static List> dataLoaderCFs = new CopyOnWriteArrayList<>(); - public static List> completedDataLoaderCFs = new CopyOnWriteArrayList<>(); - public static Set> completedCfs = ConcurrentHashMap.newKeySet(); +// public static List> completedDataLoaderCFs = new CopyOnWriteArrayList<>(); +// public static Set> completedCfs = ConcurrentHashMap.newKeySet(); /** * Creates a new incomplete CF. @@ -2369,14 +2367,14 @@ private void newInstance() { if ((this instanceof DataLoaderCF)) { dataLoaderCFs.add((DataLoaderCF) this); } else { - allNormalCFs.add(this); +// allNormalCFs.add(this); // System.out.println("new CF instance " + this + " total count" + allNormalCFs.size()); } } private void afterCompletedInternal() { if (this.result != null && !(this instanceof DataLoaderCF)) { - completedCfs.add(this); +// completedCfs.add(this); // System.out.println("completed CF instance " + this + " completed count: " + completedCfs.size()); } } @@ -3666,25 +3664,6 @@ public static CF newDataLoaderCF(DataFetchingEnvironment environment, Str public static void main(String[] args) { - CompletableFuture future = new CompletableFuture<>(); - future.thenApply(o -> { - System.out.println("1"); - return null; - }).thenAccept(o -> { - System.out.println("1-1"); - }).thenAccept(o -> { - System.out.println("1-2"); - }); - future.thenApply(o -> { - System.out.println("2"); - return null; - }).thenAccept(o -> { - System.out.println("2-1"); - }).thenAccept(o -> { - ; - System.out.println("2-2"); - }); - future.complete(null); } } diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index 738f52bfc5..5f2d2129ef 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -130,8 +130,13 @@ class GraphQLTest extends Specification { return CF.newDataLoaderCF(env, "name", "Key1").thenCompose { result -> { - println "finished Dog outer DF with $result" - return CF.newDataLoaderCF(env, "name", result) + CF.supplyAsync({ + Thread.sleep(500) + return ""; + }).thenCompose { + println "finished Dog outer DF with $result" + return CF.newDataLoaderCF(env, "name", result) + } } } } as DataFetcher From 0601b838cf3837679b0f615dc16b0192b8402b0e Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 26 Mar 2025 21:36:07 +1000 Subject: [PATCH 11/19] cleanup --- src/test/groovy/graphql/GraphQLTest.groovy | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index 5f2d2129ef..dec1ede01f 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -130,13 +130,13 @@ class GraphQLTest extends Specification { return CF.newDataLoaderCF(env, "name", "Key1").thenCompose { result -> { - CF.supplyAsync({ - Thread.sleep(500) - return ""; - }).thenCompose { +// CF.supplyAsync({ +// Thread.sleep(500) +// return ""; +// }).thenCompose { println "finished Dog outer DF with $result" return CF.newDataLoaderCF(env, "name", result) - } +// } } } } as DataFetcher From ea046d2692d75b0b877e53fe6957ebb4113fd5b3 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Thu, 27 Mar 2025 10:07:41 +1000 Subject: [PATCH 12/19] move test --- .../groovy/graphql/CFDataLoaderTest.groovy | 135 ++++++++++++++++++ src/test/groovy/graphql/GraphQLTest.groovy | 73 ---------- 2 files changed, 135 insertions(+), 73 deletions(-) create mode 100644 src/test/groovy/graphql/CFDataLoaderTest.groovy diff --git a/src/test/groovy/graphql/CFDataLoaderTest.groovy b/src/test/groovy/graphql/CFDataLoaderTest.groovy new file mode 100644 index 0000000000..ded8864365 --- /dev/null +++ b/src/test/groovy/graphql/CFDataLoaderTest.groovy @@ -0,0 +1,135 @@ +package graphql + +import graphql.execution.CF +import graphql.schema.DataFetcher +import org.dataloader.BatchLoader +import org.dataloader.DataLoader +import org.dataloader.DataLoaderFactory +import org.dataloader.DataLoaderRegistry +import spock.lang.Specification + +import java.util.concurrent.CompletableFuture + +import static graphql.ExecutionInput.newExecutionInput + +class CFDataLoaderTest extends Specification { + + + def "chained data loaders"() { + given: + def sdl = ''' + + type Query { + dogName: String + catName: String + } + ''' + int batchLoadCalls = 0 + BatchLoader batchLoader = { keys -> + return CompletableFuture.supplyAsync { + batchLoadCalls++ + Thread.sleep(250) + println "BatchLoader called with keys: $keys" + assert keys.size() == 2 + return ["Luna", "Tiger"] + } + } + + DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); + + DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); + dataLoaderRegistry.register("name", nameDataLoader); + + def df1 = { env -> + return CF.newDataLoaderCF(env, "name", "Key1").thenCompose { + result -> + { + return CF.newDataLoaderCF(env, "name", result) + } + } + } as DataFetcher + + def df2 = { env -> + return CF.newDataLoaderCF(env, "name", "Key2").thenCompose { + result -> + { + return CF.newDataLoaderCF(env, "name", result) + } + } + } as DataFetcher + + + def fetchers = ["Query": ["dogName": df1, "catName": df2]] + def schema = TestUtil.schema(sdl, fetchers) + def graphQL = GraphQL.newGraphQL(schema).build() + + def query = "{ dogName catName } " + def ei = newExecutionInput(query).dataLoaderRegistry(dataLoaderRegistry).build() + + when: + def er = graphQL.execute(ei) + then: + er.data == [dogName: "Luna", catName: "Tiger"] + batchLoadCalls == 2 + } + + def "chained data loaders with second one delayed"() { + given: + def sdl = ''' + + type Query { + dogName: String + catName: String + } + ''' + int batchLoadCalls = 0 + BatchLoader batchLoader = { keys -> + return CompletableFuture.supplyAsync { + batchLoadCalls++ + Thread.sleep(250) + println "BatchLoader called with keys: $keys" + assert keys.size() == 2 + return ["Luna", "Tiger"] + } + } + + DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); + + DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); + dataLoaderRegistry.register("name", nameDataLoader); + + def df1 = { env -> + return CF.newDataLoaderCF(env, "name", "Key1").thenCompose { + result -> + { + return CF.newDataLoaderCF(env, "name", result) + } + } + } as DataFetcher + + def df2 = { env -> + return CF.newDataLoaderCF(env, "name", "Key2").thenCompose { + result -> + { + return CF.newDataLoaderCF(env, "name", result) + } + } + } as DataFetcher + + + def fetchers = ["Query": ["dogName": df1, "catName": df2]] + def schema = TestUtil.schema(sdl, fetchers) + def graphQL = GraphQL.newGraphQL(schema).build() + + def query = "{ dogName catName } " + def ei = newExecutionInput(query).dataLoaderRegistry(dataLoaderRegistry).build() + + when: + def er = graphQL.execute(ei) + then: + er.data == [dogName: "Luna", catName: "Tiger"] + batchLoadCalls == 2 + } + + +} diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index dec1ede01f..124baa42c3 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -4,7 +4,6 @@ import graphql.analysis.MaxQueryComplexityInstrumentation import graphql.analysis.MaxQueryDepthInstrumentation import graphql.execution.AsyncExecutionStrategy import graphql.execution.AsyncSerialExecutionStrategy -import graphql.execution.CF import graphql.execution.DataFetcherExceptionHandler import graphql.execution.DataFetcherExceptionHandlerParameters import graphql.execution.DataFetcherExceptionHandlerResult @@ -39,10 +38,6 @@ import graphql.schema.idl.errors.SchemaProblem import graphql.schema.validation.InvalidSchemaException import graphql.validation.ValidationError import graphql.validation.ValidationErrorType -import org.dataloader.BatchLoader -import org.dataloader.DataLoader -import org.dataloader.DataLoaderFactory -import org.dataloader.DataLoaderRegistry import spock.lang.Specification import spock.lang.Unroll @@ -97,74 +92,6 @@ class GraphQLTest extends Specification { result == [hello: 'world'] } - def "to batch"() { - given: - def sdl = ''' - - type Query { - dogName: String - catName: String - } - ''' - BatchLoader batchLoader = { keys -> - return CompletableFuture.supplyAsync { - Thread.sleep(1000) - println "BatchLoader called with keys: $keys" - if (keys.size() == 1) { - return ["ONLY ONE KEY"] - } else { - return ["Luna", "Tiger"] - } - } - } - - DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); - - DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); - // - // we make sure our dataloader is in the registry - dataLoaderRegistry.register("name", nameDataLoader); - - def df1 = { env -> - println "DF1" - return CF.newDataLoaderCF(env, "name", "Key1").thenCompose { - result -> - { -// CF.supplyAsync({ -// Thread.sleep(500) -// return ""; -// }).thenCompose { - println "finished Dog outer DF with $result" - return CF.newDataLoaderCF(env, "name", result) -// } - } - } - } as DataFetcher - - def df2 = { env -> - println "DF2" - return CF.newDataLoaderCF(env, "name", "Key2").thenCompose { - result -> - { - println "finished Cat outer DF with $result" - return CF.newDataLoaderCF(env, "name", result) - } - } - } as DataFetcher - - - def fetchers = ["Query": ["dogName": df1, "catName": df2]] - def schema = TestUtil.schema(sdl, fetchers) - def graphQL = GraphQL.newGraphQL(schema).build() - - def query = "{ dogName catName } " - def ei = newExecutionInput(query).dataLoaderRegistry(dataLoaderRegistry).build() - - when: - def er = graphQL.execute(ei) - then: - er.data == [dogName: "Luna", catName: "Tiger"] - } def "query with sub-fields"() { From a2c3b2b0fe945aebbbc7c6443e2ecd2594a23978 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Thu, 27 Mar 2025 12:07:51 +1000 Subject: [PATCH 13/19] wip --- src/main/java/graphql/execution/CF.java | 101 +++++++++++++---- .../java/graphql/execution/Execution.java | 6 +- .../graphql/execution/ExecutionContext.java | 1 + .../PerLevelDataLoaderDispatchStrategy.java | 2 +- .../groovy/graphql/CFDataLoaderTest.groovy | 107 ++++++++++++++++-- 5 files changed, 183 insertions(+), 34 deletions(-) diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index bd22f36f83..74a5598915 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -6,25 +6,34 @@ * http://creativecommons.org/publicdomain/zero/1.0/ */ +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Multimap; +import com.google.common.collect.Multimaps; import graphql.schema.DataFetchingEnvironment; import org.dataloader.DataLoaderRegistry; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.concurrent.CancellationException; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; import java.util.concurrent.CompletionStage; -import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor; +import java.util.concurrent.Executors; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinTask; import java.util.concurrent.Future; import java.util.concurrent.FutureTask; +import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.ThreadFactory; @@ -37,6 +46,8 @@ import java.util.function.Function; import java.util.function.Supplier; +import static graphql.execution.Execution.EXECUTION_CONTEXT_KEY; + /** * A {@link Future} that may be explicitly completed (setting its * value and status), and may be used as a {@link CompletionStage}, @@ -2342,10 +2353,8 @@ private Object timedGet(long nanos) throws TimeoutException { /* ------------- public methods -------------- */ - // public static CopyOnWriteArrayList> allNormalCFs = new CopyOnWriteArrayList<>(); - public static List> dataLoaderCFs = new CopyOnWriteArrayList<>(); -// public static List> completedDataLoaderCFs = new CopyOnWriteArrayList<>(); -// public static Set> completedCfs = ConcurrentHashMap.newKeySet(); + static Multimap> executionToDataLoaderCFs = Multimaps.synchronizedMultimap(HashMultimap.create()); + static Map> executionToFinishedDispatchingDFEs = new ConcurrentHashMap<>(); /** * Creates a new incomplete CF. @@ -2365,7 +2374,7 @@ public CF() { private void newInstance() { if ((this instanceof DataLoaderCF)) { - dataLoaderCFs.add((DataLoaderCF) this); +// dataLoaderCFs.add((DataLoaderCF) this); } else { // allNormalCFs.add(this); // System.out.println("new CF instance " + this + " total count" + allNormalCFs.size()); @@ -3577,32 +3586,36 @@ public CF toCompletableFuture() { } private static class DataLoaderCF extends CF { - final DataLoaderRegistry registry; + final DataFetchingEnvironment dfe; final String dataLoaderName; final Object key; final CompletableFuture dataLoaderCF; volatile CountDownLatch latch; - public DataLoaderCF(DataLoaderRegistry registry, String dataLoaderName, Object key) { - this.registry = registry; + public DataLoaderCF(DataFetchingEnvironment dfe, String dataLoaderName, Object key) { + this.dfe = dfe; this.dataLoaderName = dataLoaderName; this.key = key; - dataLoaderCF = registry.getDataLoader(dataLoaderName).load(key); - dataLoaderCF.whenComplete((value, throwable) -> { - if (throwable != null) { - completeExceptionally(throwable); - } else { - complete((T) value); - } - if (latch != null) { - latch.countDown(); - } - }); + if (dataLoaderName != null) { + dataLoaderCF = dfe.getDataLoaderRegistry().getDataLoader(dataLoaderName).load(key); + dataLoaderCF.whenComplete((value, throwable) -> { + if (throwable != null) { + completeExceptionally(throwable); + } else { + complete((T) value); + } + if (latch != null) { + latch.countDown(); + } + }); + } else { + dataLoaderCF = null; + } } DataLoaderCF() { - this.registry = null; + this.dfe = null; this.dataLoaderName = null; this.key = null; dataLoaderCF = null; @@ -3615,16 +3628,28 @@ public CF newIncompleteFuture() { } } - public static void dispatch(DataLoaderRegistry dataLoaderRegistry) { + + public static void dispatch(ExecutionContext executionContext) { + dispatchImpl(executionContext, executionContext.getDataLoaderRegistry(), new LinkedHashSet<>()); + } + + static final ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(); + + public static void dispatchImpl(ExecutionContext executionContext, DataLoaderRegistry dataLoaderRegistry, Set seenDFEs) { + Collection> dataLoaderCFs = executionToDataLoaderCFs.get(executionContext); if (dataLoaderCFs.size() == 0) { + executionToFinishedDispatchingDFEs.put(executionContext, seenDFEs); dataLoaderRegistry.dispatchAll(); return; } + // we are dispatching all data loaders and waiting for all dataLoaderCFs to complete + // and to finish their sync actions List> dataLoaderCFCopy = new ArrayList<>(dataLoaderCFs); dataLoaderCFs.clear(); CountDownLatch countDownLatch = new CountDownLatch(dataLoaderCFCopy.size()); for (DataLoaderCF dlCF : dataLoaderCFCopy) { dlCF.latch = countDownLatch; + seenDFEs.add(dlCF.dfe); } new Thread(() -> { try { @@ -3633,13 +3658,39 @@ public static void dispatch(DataLoaderRegistry dataLoaderRegistry) { } catch (InterruptedException e) { throw new RuntimeException(e); } - dispatch(dataLoaderRegistry); + // now we handle all new DataLoaders + dispatchImpl(executionContext, dataLoaderRegistry, seenDFEs); }).start(); dataLoaderRegistry.dispatchAll(); } - public static CF newDataLoaderCF(DataFetchingEnvironment environment, String dataLoaderName, Object key) { - return new DataLoaderCF<>(environment.getDataLoaderRegistry(), dataLoaderName, key); + static final int BATCH_WINDOW_NANO_SECONDS = 500_000; + + private static void dispatchIsolatedDataLoader(DataLoaderCF dlCF) { + Runnable runnable = () -> { + dispatch(dlCF.dfe.getGraphQlContext().get(EXECUTION_CONTEXT_KEY)); + }; + scheduledExecutorService.schedule(runnable, BATCH_WINDOW_NANO_SECONDS, TimeUnit.NANOSECONDS); + } + + public static CF newDataLoaderCF(DataFetchingEnvironment dfe, String dataLoaderName, Object key) { + DataLoaderCF result = new DataLoaderCF<>(dfe, dataLoaderName, key); + ExecutionContext executionContext = dfe.getGraphQlContext().get(EXECUTION_CONTEXT_KEY); + executionToDataLoaderCFs.put(executionContext, result); + // this means it is a new DataLoader that was created during a DataFetcher after the + // dispatching for this fields was done already, so we need to handle it extra + Set finishedDFe = executionToFinishedDispatchingDFEs.get(executionContext); + if (finishedDFe != null && finishedDFe.contains(dfe)) { + dispatchIsolatedDataLoader(result); + } + return result; + } + + public static CF supplyAsyncDataLoaderCF(DataFetchingEnvironment env, Supplier supplier) { + DataLoaderCF d = new DataLoaderCF<>(env, null, null); + ASYNC_POOL.execute(new AsyncSupply(d, supplier)); + return d; + } // Replaced misc unsafe with VarHandle diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java index 0fa7734f45..9441adcd4d 100644 --- a/src/main/java/graphql/execution/Execution.java +++ b/src/main/java/graphql/execution/Execution.java @@ -57,6 +57,9 @@ public class Execution { private final ValueUnboxer valueUnboxer; private final boolean doNotAutomaticallyDispatchDataLoader; + + public static final String EXECUTION_CONTEXT_KEY = "__GraphQL_Java_ExecutionContext"; + public Execution(ExecutionStrategy queryStrategy, ExecutionStrategy mutationStrategy, ExecutionStrategy subscriptionStrategy, @@ -113,6 +116,7 @@ public CompletableFuture execute(Document document, GraphQLSche .build(); executionContext.getGraphQLContext().put(ResultNodesInfo.RESULT_NODES_INFO, executionContext.getResultNodesInfo()); + executionContext.getGraphQLContext().put(EXECUTION_CONTEXT_KEY, executionContext); InstrumentationExecutionParameters parameters = new InstrumentationExecutionParameters( executionInput, graphQLSchema @@ -288,7 +292,7 @@ private ExecutionResult mergeExtensionsBuilderIfPresent(ExecutionResult executio private boolean propagateErrorsOnNonNullContractFailure(List directives) { boolean jvmWideEnabled = Directives.isExperimentalDisableErrorPropagationDirectiveEnabled(); - if (! jvmWideEnabled) { + if (!jvmWideEnabled) { return true; } Directive foundDirective = NodeUtil.findNodeByName(directives, EXPERIMENTAL_DISABLE_ERROR_PROPAGATION_DIRECTIVE_DEFINITION.getName()); diff --git a/src/main/java/graphql/execution/ExecutionContext.java b/src/main/java/graphql/execution/ExecutionContext.java index b166b19025..00b3c035f0 100644 --- a/src/main/java/graphql/execution/ExecutionContext.java +++ b/src/main/java/graphql/execution/ExecutionContext.java @@ -36,6 +36,7 @@ @PublicApi public class ExecutionContext { + private final GraphQLSchema graphQLSchema; private final ExecutionId executionId; private final InstrumentationState instrumentationState; diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java index 5f368a256a..1cb7a73954 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java @@ -277,7 +277,7 @@ private boolean levelReady(int level) { void dispatch(int level) { DataLoaderRegistry dataLoaderRegistry = executionContext.getDataLoaderRegistry(); - CF.dispatch(dataLoaderRegistry); + CF.dispatch(executionContext); // dataLoaderRegistry.dispatchAll(); } diff --git a/src/test/groovy/graphql/CFDataLoaderTest.groovy b/src/test/groovy/graphql/CFDataLoaderTest.groovy index ded8864365..d6eef6470b 100644 --- a/src/test/groovy/graphql/CFDataLoaderTest.groovy +++ b/src/test/groovy/graphql/CFDataLoaderTest.groovy @@ -73,6 +73,93 @@ class CFDataLoaderTest extends Specification { batchLoadCalls == 2 } + def "more complicated chained data loader for one DF"() { + given: + def sdl = ''' + + type Query { + foo: String + } + ''' + int batchLoadCalls1 = 0 + BatchLoader batchLoader1 = { keys -> + return CompletableFuture.supplyAsync { + batchLoadCalls1++ + Thread.sleep(250) + println "BatchLoader1 called with keys: $keys" + return keys.collect { String key -> + key + "-batchloader1" + } + } + } + int batchLoadCalls2 = 0 + BatchLoader batchLoader2 = { keys -> + return CompletableFuture.supplyAsync { + batchLoadCalls2++ + Thread.sleep(250) + println "BatchLoader2 called with keys: $keys" + return keys.collect { String key -> + key + "-batchloader2" + } + } + } + + + DataLoader dl1 = DataLoaderFactory.newDataLoader(batchLoader1); + DataLoader dl2 = DataLoaderFactory.newDataLoader(batchLoader2); + + DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); + dataLoaderRegistry.register("dl1", dl1); + dataLoaderRegistry.register("dl2", dl2); + + def df = { env -> + return CF.newDataLoaderCF(env, "dl1", "start").thenCompose { + firstDLResult -> + + def otherCF1 = CF.supplyAsyncDataLoaderCF(env, { + Thread.sleep(1000) + return "otherCF1" + }) + def otherCF2 = CF.supplyAsyncDataLoaderCF(env, { + Thread.sleep(1000) + return "otherCF2" + }) + + def secondDL = CF.newDataLoaderCF(env, "dl2", firstDLResult).thenApply { + secondDLResult -> + return secondDLResult + "-apply" + } + return otherCF1.thenCompose { + otherCF1Result -> + otherCF2.thenCompose { + otherCF2Result -> + secondDL.thenApply { + secondDLResult -> + return firstDLResult + "-" + otherCF1Result + "-" + otherCF2Result + "-" + secondDLResult + } + } + } + + } + } as DataFetcher + + + def fetchers = ["Query": ["foo": df]] + def schema = TestUtil.schema(sdl, fetchers) + def graphQL = GraphQL.newGraphQL(schema).build() + + def query = "{ foo } " + def ei = newExecutionInput(query).dataLoaderRegistry(dataLoaderRegistry).build() + + when: + def er = graphQL.execute(ei) + then: + er.data == [foo: "start-batchloader1-otherCF1-otherCF2-start-batchloader1-batchloader2-apply"] + batchLoadCalls1 == 1 + batchLoadCalls2 == 1 + } + + def "chained data loaders with second one delayed"() { given: def sdl = ''' @@ -88,8 +175,9 @@ class CFDataLoaderTest extends Specification { batchLoadCalls++ Thread.sleep(250) println "BatchLoader called with keys: $keys" - assert keys.size() == 2 - return ["Luna", "Tiger"] + return keys.collect { String key -> + key.substring(0, key.length() - 1) + (Integer.parseInt(key.substring(key.length() - 1, key.length())) + 1) + } } } @@ -99,16 +187,21 @@ class CFDataLoaderTest extends Specification { dataLoaderRegistry.register("name", nameDataLoader); def df1 = { env -> - return CF.newDataLoaderCF(env, "name", "Key1").thenCompose { + return CF.newDataLoaderCF(env, "name", "Luna0").thenCompose { result -> { - return CF.newDataLoaderCF(env, "name", result) + return CF.supplyAsyncDataLoaderCF(env, { + Thread.sleep(1000) + return "foo" + }).thenCompose { + return CF.newDataLoaderCF(env, "name", result) + } } } } as DataFetcher def df2 = { env -> - return CF.newDataLoaderCF(env, "name", "Key2").thenCompose { + return CF.newDataLoaderCF(env, "name", "Tiger0").thenCompose { result -> { return CF.newDataLoaderCF(env, "name", result) @@ -127,8 +220,8 @@ class CFDataLoaderTest extends Specification { when: def er = graphQL.execute(ei) then: - er.data == [dogName: "Luna", catName: "Tiger"] - batchLoadCalls == 2 + er.data == [dogName: "Luna2", catName: "Tiger2"] + batchLoadCalls == 3 } From a26d3678a72cacd84491349d40bcf63c754b1126 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Thu, 27 Mar 2025 13:25:11 +1000 Subject: [PATCH 14/19] wip --- src/main/java/graphql/execution/CF.java | 84 ++++++++++++++----- .../execution/DataLoaderDispatchStrategy.java | 3 + .../graphql/execution/ExecutionStrategy.java | 2 +- .../PerLevelDataLoaderDispatchStrategy.java | 22 ++++- ...spatchStrategyWithDeferAlwaysDispatch.java | 4 +- .../groovy/graphql/CFDataLoaderTest.groovy | 59 ++++++++++++- 6 files changed, 148 insertions(+), 26 deletions(-) diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index 74a5598915..40ad624857 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -10,7 +10,6 @@ import com.google.common.collect.Multimap; import com.google.common.collect.Multimaps; import graphql.schema.DataFetchingEnvironment; -import org.dataloader.DataLoaderRegistry; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; @@ -2355,6 +2354,7 @@ private Object timedGet(long nanos) throws TimeoutException { static Multimap> executionToDataLoaderCFs = Multimaps.synchronizedMultimap(HashMultimap.create()); static Map> executionToFinishedDispatchingDFEs = new ConcurrentHashMap<>(); + static Map> executionToDfWithDataLoaderCF = new ConcurrentHashMap<>(); /** * Creates a new incomplete CF. @@ -3624,32 +3624,37 @@ public DataLoaderCF(DataFetchingEnvironment dfe, String dataLoaderName, Object k @Override public CF newIncompleteFuture() { - return new CF<>(); + return new DataLoaderCF<>(); } } - public static void dispatch(ExecutionContext executionContext) { - dispatchImpl(executionContext, executionContext.getDataLoaderRegistry(), new LinkedHashSet<>()); + public static void dispatch(ExecutionContext executionContext, Set dfeToDispatch) { + dispatchImpl(executionContext, dfeToDispatch); } static final ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(); - public static void dispatchImpl(ExecutionContext executionContext, DataLoaderRegistry dataLoaderRegistry, Set seenDFEs) { + + public static void dispatchImpl(ExecutionContext executionContext, Set dfeToDispatchSet) { + Collection> dataLoaderCFs = executionToDataLoaderCFs.get(executionContext); - if (dataLoaderCFs.size() == 0) { - executionToFinishedDispatchingDFEs.put(executionContext, seenDFEs); - dataLoaderRegistry.dispatchAll(); + List> relevantDataLoaderCFs = new ArrayList<>(); + for (DataLoaderCF dataLoaderCF : dataLoaderCFs) { + if (dfeToDispatchSet.contains(dataLoaderCF.dfe)) { + relevantDataLoaderCFs.add(dataLoaderCF); + } + } + dataLoaderCFs.removeAll(relevantDataLoaderCFs); + if (relevantDataLoaderCFs.size() == 0) { + executionToFinishedDispatchingDFEs.computeIfAbsent(executionContext, __ -> new LinkedHashSet<>()).addAll(dfeToDispatchSet); return; } // we are dispatching all data loaders and waiting for all dataLoaderCFs to complete // and to finish their sync actions - List> dataLoaderCFCopy = new ArrayList<>(dataLoaderCFs); - dataLoaderCFs.clear(); - CountDownLatch countDownLatch = new CountDownLatch(dataLoaderCFCopy.size()); - for (DataLoaderCF dlCF : dataLoaderCFCopy) { + CountDownLatch countDownLatch = new CountDownLatch(relevantDataLoaderCFs.size()); + for (DataLoaderCF dlCF : relevantDataLoaderCFs) { dlCF.latch = countDownLatch; - seenDFEs.add(dlCF.dfe); } new Thread(() -> { try { @@ -3659,18 +3664,31 @@ public static void dispatchImpl(ExecutionContext executionContext, DataLoaderReg throw new RuntimeException(e); } // now we handle all new DataLoaders - dispatchImpl(executionContext, dataLoaderRegistry, seenDFEs); + dispatchImpl(executionContext, dfeToDispatchSet); }).start(); - dataLoaderRegistry.dispatchAll(); + executionContext.getDataLoaderRegistry().dispatchAll(); } static final int BATCH_WINDOW_NANO_SECONDS = 500_000; - private static void dispatchIsolatedDataLoader(DataLoaderCF dlCF) { - Runnable runnable = () -> { - dispatch(dlCF.dfe.getGraphQlContext().get(EXECUTION_CONTEXT_KEY)); - }; - scheduledExecutorService.schedule(runnable, BATCH_WINDOW_NANO_SECONDS, TimeUnit.NANOSECONDS); + static final Map> batchWindowOfDfeToDispatch = new ConcurrentHashMap<>(); + static final Set scheduledExecutionContexts = ConcurrentHashMap.newKeySet(); + + private static void dispatchIsolatedDataLoader(ExecutionContext executionContext, DataLoaderCF dlCF) { + synchronized (batchWindowOfDfeToDispatch) { + batchWindowOfDfeToDispatch.computeIfAbsent(executionContext, __ -> new LinkedHashSet<>()).add(dlCF.dfe); + if (!scheduledExecutionContexts.contains(executionContext)) { + System.out.println("new scheduled"); + scheduledExecutionContexts.add(executionContext); + Runnable runnable = () -> { + scheduledExecutionContexts.remove(executionContext); + dispatch(executionContext, batchWindowOfDfeToDispatch.remove(executionContext)); + }; + scheduledExecutorService.schedule(runnable, BATCH_WINDOW_NANO_SECONDS, TimeUnit.NANOSECONDS); + } else { + System.out.println("already scheduled"); + } + } } public static CF newDataLoaderCF(DataFetchingEnvironment dfe, String dataLoaderName, Object key) { @@ -3681,18 +3699,42 @@ public static CF newDataLoaderCF(DataFetchingEnvironment dfe, String data // dispatching for this fields was done already, so we need to handle it extra Set finishedDFe = executionToFinishedDispatchingDFEs.get(executionContext); if (finishedDFe != null && finishedDFe.contains(dfe)) { - dispatchIsolatedDataLoader(result); + System.out.println("isolation dispatch"); + dispatchIsolatedDataLoader(executionContext, result); + } else { + System.out.println("no isolation dispatch"); } return result; } public static CF supplyAsyncDataLoaderCF(DataFetchingEnvironment env, Supplier supplier) { DataLoaderCF d = new DataLoaderCF<>(env, null, null); + ExecutionContext executionContext = env.getGraphQlContext().get(EXECUTION_CONTEXT_KEY); + executionToDfWithDataLoaderCF.computeIfAbsent(executionContext, ignored -> new LinkedHashSet<>()).add(env); ASYNC_POOL.execute(new AsyncSupply(d, supplier)); return d; } + public static CF wrapDataLoaderCF(DataFetchingEnvironment env, CompletableFuture completableFuture) { + DataLoaderCF d = new DataLoaderCF<>(env, null, null); + ExecutionContext executionContext = env.getGraphQlContext().get(EXECUTION_CONTEXT_KEY); + executionToDfWithDataLoaderCF.computeIfAbsent(executionContext, ignored -> new LinkedHashSet<>()).add(env); + completableFuture.whenComplete((u, ex) -> { + if (ex != null) { + d.completeExceptionally(ex); + } else { + d.complete(u); + } + }); + return d; + } + + public static boolean isDataLoaderCF(Object fetchedValue) { + return fetchedValue instanceof DataLoaderCF; + } + + // Replaced misc unsafe with VarHandle private static final VarHandle RESULT; private static final VarHandle STACK; diff --git a/src/main/java/graphql/execution/DataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/DataLoaderDispatchStrategy.java index 5101ae3a56..3d029ab4c8 100644 --- a/src/main/java/graphql/execution/DataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/DataLoaderDispatchStrategy.java @@ -2,8 +2,10 @@ import graphql.Internal; import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; import java.util.List; +import java.util.function.Supplier; @Internal public interface DataLoaderDispatchStrategy { @@ -42,6 +44,7 @@ default void executeObjectOnFieldValuesException(Throwable t, ExecutionStrategyP } default void fieldFetched(ExecutionContext executionContext, + Supplier dataFetchingEnvironment, ExecutionStrategyParameters executionStrategyParameters, DataFetcher dataFetcher, Object fetchedValue) { diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java index daadc82aa9..eba693d2d6 100644 --- a/src/main/java/graphql/execution/ExecutionStrategy.java +++ b/src/main/java/graphql/execution/ExecutionStrategy.java @@ -496,7 +496,7 @@ private Object fetchField(GraphQLFieldDefinition fieldDef, ExecutionContext exec dataFetcher = instrumentation.instrumentDataFetcher(dataFetcher, instrumentationFieldFetchParams, executionContext.getInstrumentationState()); dataFetcher = executionContext.getDataLoaderDispatcherStrategy().modifyDataFetcher(dataFetcher); Object fetchedObject = invokeDataFetcher(executionContext, parameters, fieldDef, dataFetchingEnvironment, dataFetcher); - executionContext.getDataLoaderDispatcherStrategy().fieldFetched(executionContext, parameters, dataFetcher, fetchedObject); + executionContext.getDataLoaderDispatcherStrategy().fieldFetched(executionContext, dataFetchingEnvironment, parameters, dataFetcher, fetchedObject); fetchCtx.onDispatched(); fetchCtx.onFetchedValue(fetchedObject); // if it's a subscription, leave any reactive objects alone diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java index 1cb7a73954..82f48bfc39 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java @@ -8,12 +8,16 @@ import graphql.execution.ExecutionStrategyParameters; import graphql.execution.FieldValueInfo; import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; import graphql.util.LockKit; import org.dataloader.DataLoaderRegistry; import java.util.LinkedHashSet; import java.util.List; +import java.util.Map; import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; @Internal public class PerLevelDataLoaderDispatchStrategy implements DataLoaderDispatchStrategy { @@ -35,10 +39,16 @@ private static class CallStack { private final Set dispatchedLevels = new LinkedHashSet<>(); + private final Map> dataFetchingEnvironmentMap = new ConcurrentHashMap<>(); + public CallStack() { expectedExecuteObjectCallsPerLevel.set(1, 1); } + public void addDataLoaderDFE(int level, DataFetchingEnvironment dfe) { + dataFetchingEnvironmentMap.computeIfAbsent(level, k -> new LinkedHashSet<>()).add(dfe); + } + void increaseExpectedFetchCount(int level, int count) { expectedFetchCountPerLevel.increment(level, count); } @@ -233,12 +243,17 @@ private int getObjectCountForList(List fieldValueInfos) { @Override public void fieldFetched(ExecutionContext executionContext, + Supplier dataFetchingEnvironment, ExecutionStrategyParameters executionStrategyParameters, DataFetcher dataFetcher, Object fetchedValue) { int level = executionStrategyParameters.getPath().getLevel(); boolean dispatchNeeded = callStack.lock.callLocked(() -> { callStack.increaseFetchCount(level); + if (CF.isDataLoaderCF(fetchedValue)) { + callStack.addDataLoaderDFE(level, dataFetchingEnvironment.get()); + } + callStack.increaseExpectedExecuteObjectCalls(level + 1, 1); return dispatchIfNeeded(level); }); if (dispatchNeeded) { @@ -277,8 +292,11 @@ private boolean levelReady(int level) { void dispatch(int level) { DataLoaderRegistry dataLoaderRegistry = executionContext.getDataLoaderRegistry(); - CF.dispatch(executionContext); -// dataLoaderRegistry.dispatchAll(); + if (callStack.dataFetchingEnvironmentMap.isEmpty()) { + dataLoaderRegistry.dispatchAll(); + } else { + CF.dispatch(executionContext, callStack.dataFetchingEnvironmentMap.get(level)); + } } } diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyWithDeferAlwaysDispatch.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyWithDeferAlwaysDispatch.java index 26c847b754..224bd87554 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyWithDeferAlwaysDispatch.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyWithDeferAlwaysDispatch.java @@ -7,6 +7,7 @@ import graphql.execution.ExecutionStrategyParameters; import graphql.execution.FieldValueInfo; import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; import graphql.util.LockKit; import org.dataloader.DataLoaderRegistry; @@ -14,6 +15,7 @@ import java.util.List; import java.util.Set; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Supplier; /** * The execution of a query can be divided into 2 phases: first, the non-deferred fields are executed and only once @@ -171,7 +173,7 @@ public void executeObjectOnFieldValuesException(Throwable t, ExecutionStrategyPa @Override public void fieldFetched(ExecutionContext executionContext, - ExecutionStrategyParameters parameters, + Supplier dataFetchingEnvironment, ExecutionStrategyParameters parameters, DataFetcher dataFetcher, Object fetchedValue) { diff --git a/src/test/groovy/graphql/CFDataLoaderTest.groovy b/src/test/groovy/graphql/CFDataLoaderTest.groovy index d6eef6470b..b9a482fb87 100644 --- a/src/test/groovy/graphql/CFDataLoaderTest.groovy +++ b/src/test/groovy/graphql/CFDataLoaderTest.groovy @@ -160,7 +160,7 @@ class CFDataLoaderTest extends Specification { } - def "chained data loaders with second one delayed"() { + def "chained data loaders with an isolated data loader"() { given: def sdl = ''' @@ -224,5 +224,62 @@ class CFDataLoaderTest extends Specification { batchLoadCalls == 3 } + def "chained data loaders with two isolated data loaders"() { + given: + def sdl = ''' + + type Query { + foo: String + bar: String + } + ''' + int batchLoadCalls = 0 + BatchLoader batchLoader = { keys -> + return CompletableFuture.supplyAsync { + batchLoadCalls++ + Thread.sleep(250) + println "BatchLoader called with keys: $keys" + return keys; + } + } + + DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); + + DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); + dataLoaderRegistry.register("dl", nameDataLoader); + + def fooDF = { env -> + return CF.supplyAsyncDataLoaderCF(env, { + Thread.sleep(1000) + return "fooFirstValue" + }).thenCompose { + return CF.newDataLoaderCF(env, "dl", it) + } + } as DataFetcher + + def barDF = { env -> + return CF.supplyAsyncDataLoaderCF(env, { + Thread.sleep(1000) + return "barFirstValue" + }).thenCompose { + return CF.newDataLoaderCF(env, "dl", it) + } + } as DataFetcher + + + def fetchers = ["Query": ["foo": fooDF, "bar": barDF]] + def schema = TestUtil.schema(sdl, fetchers) + def graphQL = GraphQL.newGraphQL(schema).build() + + def query = "{ foo bar } " + def ei = newExecutionInput(query).dataLoaderRegistry(dataLoaderRegistry).build() + + when: + def er = graphQL.execute(ei) + then: + er.data == [foo: "fooFirstValue", bar: "barFirstValue"] + batchLoadCalls == 1 + } + } From 6c4abb7d3a26f11dc3a7441a14b234a33f7dc48f Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Thu, 27 Mar 2025 13:35:00 +1000 Subject: [PATCH 15/19] wip --- .../dataloader/PerLevelDataLoaderDispatchStrategy.java | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java index 82f48bfc39..cc0e04b29b 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java @@ -253,7 +253,6 @@ public void fieldFetched(ExecutionContext executionContext, if (CF.isDataLoaderCF(fetchedValue)) { callStack.addDataLoaderDFE(level, dataFetchingEnvironment.get()); } - callStack.increaseExpectedExecuteObjectCalls(level + 1, 1); return dispatchIfNeeded(level); }); if (dispatchNeeded) { @@ -292,11 +291,11 @@ private boolean levelReady(int level) { void dispatch(int level) { DataLoaderRegistry dataLoaderRegistry = executionContext.getDataLoaderRegistry(); - if (callStack.dataFetchingEnvironmentMap.isEmpty()) { +// if (callStack.dataFetchingEnvironmentMap.isEmpty()) { dataLoaderRegistry.dispatchAll(); - } else { - CF.dispatch(executionContext, callStack.dataFetchingEnvironmentMap.get(level)); - } +// } else { +// CF.dispatch(executionContext, callStack.dataFetchingEnvironmentMap.get(level)); +// } } } From 1068f0727de51f994db94c304f132d3ce7bbb627 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Thu, 27 Mar 2025 13:35:29 +1000 Subject: [PATCH 16/19] wip --- .../dataloader/PerLevelDataLoaderDispatchStrategy.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java index cc0e04b29b..d6bb8d18c6 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java @@ -291,11 +291,11 @@ private boolean levelReady(int level) { void dispatch(int level) { DataLoaderRegistry dataLoaderRegistry = executionContext.getDataLoaderRegistry(); -// if (callStack.dataFetchingEnvironmentMap.isEmpty()) { + if (callStack.dataFetchingEnvironmentMap.isEmpty()) { dataLoaderRegistry.dispatchAll(); -// } else { -// CF.dispatch(executionContext, callStack.dataFetchingEnvironmentMap.get(level)); -// } + } else { + CF.dispatch(executionContext, callStack.dataFetchingEnvironmentMap.get(level)); + } } } From 3fdc26d809dd1219a9379556bac4b627fdb736c4 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Fri, 28 Mar 2025 12:31:48 +1000 Subject: [PATCH 17/19] fix link to public domain source --- src/main/java/graphql/execution/CF.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index 40ad624857..af83752d20 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -1,5 +1,5 @@ package graphql.execution; -/* Original source from https://gee.cs.oswego.edu/dl/jsr166/src/jdk8/java/util/concurrent/CF.java +/* Original source from https://gee.cs.oswego.edu/dl/jsr166/src/jdk8/java/util/concurrent/CompletableFuture.java * * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at @@ -3605,6 +3605,7 @@ public DataLoaderCF(DataFetchingEnvironment dfe, String dataLoaderName, Object k } else { complete((T) value); } + // post completion hook if (latch != null) { latch.countDown(); } @@ -3638,6 +3639,7 @@ public static void dispatch(ExecutionContext executionContext, Set dfeToDispatchSet) { + // filter out all DataLoaderCFS that are matching the fields we want to dispatch Collection> dataLoaderCFs = executionToDataLoaderCFs.get(executionContext); List> relevantDataLoaderCFs = new ArrayList<>(); for (DataLoaderCF dataLoaderCF : dataLoaderCFs) { @@ -3666,6 +3668,7 @@ public static void dispatchImpl(ExecutionContext executionContext, Set Date: Sat, 29 Mar 2025 16:38:42 +1000 Subject: [PATCH 18/19] every CF has a ExecutionContext --- src/main/java/graphql/GraphQL.java | 25 +- .../MaxQueryComplexityInstrumentation.java | 4 +- src/main/java/graphql/execution/Async.java | 106 ++-- .../execution/AsyncExecutionStrategy.java | 7 +- .../AsyncSerialExecutionStrategy.java | 8 +- src/main/java/graphql/execution/CF.java | 476 ++++++++---------- .../graphql/execution/ExecutionStrategy.java | 65 +-- .../graphql/execution/FieldValueInfo.java | 6 +- .../SubscriptionExecutionStrategy.java | 6 +- .../incremental/DeferredExecutionSupport.java | 5 +- .../incremental/DeferredFragmentCall.java | 10 +- .../ChainedInstrumentation.java | 12 +- .../instrumentation/Instrumentation.java | 7 +- .../SimplePerformantInstrumentation.java | 7 +- .../threadpools/ExecutorInstrumentation.java | 334 ++++++------ .../tracing/TracingInstrumentation.java | 8 +- .../NoOpPreparsedDocumentProvider.java | 5 +- .../InMemoryPersistedQueryCache.java | 5 +- .../persisted/PersistedQuerySupport.java | 7 +- .../execution/reactive/ReactiveSupport.java | 15 +- .../BreadthFirstExecutionTestStrategy.java | 4 +- .../execution/BreadthFirstTestStrategy.java | 10 +- .../ExecutorInstrumentationTest.groovy | 428 ++++++++-------- src/test/java/benchmark/AsyncBenchmark.java | 2 +- 24 files changed, 791 insertions(+), 771 deletions(-) diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index 46accb5ac5..efd1bc119d 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -7,6 +7,8 @@ import graphql.execution.CF; import graphql.execution.DataFetcherExceptionHandler; import graphql.execution.Execution; +import graphql.execution.ExecutionContext; +import graphql.execution.ExecutionContextBuilder; import graphql.execution.ExecutionId; import graphql.execution.ExecutionIdProvider; import graphql.execution.ExecutionStrategy; @@ -416,8 +418,10 @@ public CompletableFuture executeAsync(UnaryOperator executeAsync(ExecutionInput executionInput) { ExecutionInput executionInputWithId = ensureInputHasId(executionInput); + ExecutionContext dummyExecutionContext = ExecutionContextBuilder.newExecutionContextBuilder().executionId(ExecutionId.generate()).build(); + CompletableFuture instrumentationStateCF = instrumentation.createStateAsync(new InstrumentationCreateStateParameters(this.graphQLSchema, executionInputWithId)); - CF rootCF = Async.orNullCompletedFuture(instrumentationStateCF); + CF rootCF = Async.orNullCompletedFuture(instrumentationStateCF, dummyExecutionContext); CF cf = rootCF.thenCompose(instrumentationState -> { try { InstrumentationExecutionParameters inputInstrumentationParameters = new InstrumentationExecutionParameters(executionInputWithId, this.graphQLSchema); @@ -429,13 +433,14 @@ public CompletableFuture executeAsync(ExecutionInput executionI GraphQLSchema graphQLSchema = instrumentation.instrumentSchema(this.graphQLSchema, instrumentationParameters, instrumentationState); - CF executionResult = parseValidateAndExecute(instrumentedExecutionInput, graphQLSchema, instrumentationState); + ExecutionContext executionContext = instrumentedExecutionInput.getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + CF executionResult = parseValidateAndExecute(instrumentedExecutionInput, graphQLSchema, instrumentationState, dummyExecutionContext); // // finish up instrumentation executionResult = executionResult.whenComplete(completeInstrumentationCtxCF(executionInstrumentation)); // // allow instrumentation to tweak the result - executionResult = executionResult.thenCompose(result -> CF.wrap(instrumentation.instrumentExecutionResult(result, instrumentationParameters, instrumentationState))); + executionResult = executionResult.thenCompose(result -> CF.wrap(instrumentation.instrumentExecutionResult(result, instrumentationParameters, instrumentationState), executionContext)); return executionResult; } catch (AbortExecutionException abortException) { return handleAbortException(executionInput, instrumentationState, abortException); @@ -445,11 +450,12 @@ public CompletableFuture executeAsync(ExecutionInput executionI } private CompletableFuture handleAbortException(ExecutionInput executionInput, InstrumentationState instrumentationState, AbortExecutionException abortException) { - CF executionResult = CF.completedFuture(abortException.toExecutionResult()); + ExecutionContext executionContext = executionInput.getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + CF executionResult = CF.completedFuture(abortException.toExecutionResult(), executionContext); InstrumentationExecutionParameters instrumentationParameters = new InstrumentationExecutionParameters(executionInput, this.graphQLSchema); // // allow instrumentation to tweak the result - executionResult = executionResult.thenCompose(result -> CF.wrap(instrumentation.instrumentExecutionResult(result, instrumentationParameters, instrumentationState))); + executionResult = executionResult.thenCompose(result -> CF.wrap(instrumentation.instrumentExecutionResult(result, instrumentationParameters, instrumentationState), executionContext)); return executionResult; } @@ -464,22 +470,23 @@ private ExecutionInput ensureInputHasId(ExecutionInput executionInput) { } - private CF parseValidateAndExecute(ExecutionInput executionInput, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState) { + private CF parseValidateAndExecute(ExecutionInput executionInput, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState, + ExecutionContext dummyExecutionContext) { AtomicReference executionInputRef = new AtomicReference<>(executionInput); Function computeFunction = transformedInput -> { // if they change the original query in the pre-parser, then we want to see it downstream from then on executionInputRef.set(transformedInput); return parseAndValidate(executionInputRef, graphQLSchema, instrumentationState); }; - CF preparsedDoc = CF.wrap(preparsedDocumentProvider.getDocumentAsync(executionInput, computeFunction)); + CF preparsedDoc = CF.wrap(preparsedDocumentProvider.getDocumentAsync(executionInput, computeFunction), dummyExecutionContext); return preparsedDoc.thenCompose(preparsedDocumentEntry -> { if (preparsedDocumentEntry.hasErrors()) { - return CF.completedFuture(new ExecutionResultImpl(preparsedDocumentEntry.getErrors())); + return CF.completedFuture(new ExecutionResultImpl(preparsedDocumentEntry.getErrors()), dummyExecutionContext); } try { return execute(executionInputRef.get(), preparsedDocumentEntry.getDocument(), graphQLSchema, instrumentationState); } catch (AbortExecutionException e) { - return CF.completedFuture(e.toExecutionResult()); + return CF.completedFuture(e.toExecutionResult(), executionInput.getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY)); } }); } diff --git a/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java b/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java index 77b9d5aa32..13adaabea9 100644 --- a/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java +++ b/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java @@ -4,6 +4,7 @@ import graphql.PublicApi; import graphql.execution.AbortExecutionException; import graphql.execution.CF; +import graphql.execution.Execution; import graphql.execution.ExecutionContext; import graphql.execution.instrumentation.InstrumentationContext; import graphql.execution.instrumentation.InstrumentationState; @@ -81,7 +82,8 @@ public MaxQueryComplexityInstrumentation(int maxComplexity, FieldComplexityCalcu @Override public @Nullable CompletableFuture createStateAsync(InstrumentationCreateStateParameters parameters) { - return CF.completedFuture(new State()); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return CF.completedFuture(new State(), executionContext); } @Override diff --git a/src/main/java/graphql/execution/Async.java b/src/main/java/graphql/execution/Async.java index 7900513b59..a14b88e293 100644 --- a/src/main/java/graphql/execution/Async.java +++ b/src/main/java/graphql/execution/Async.java @@ -71,13 +71,13 @@ public interface CombinedBuilder { * * @return a combined builder of CFs */ - public static CombinedBuilder ofExpectedSize(int expectedSize) { + public static CombinedBuilder ofExpectedSize(int expectedSize, ExecutionContext executionContext) { if (expectedSize == 0) { - return new Empty<>(); + return new Empty<>(executionContext); } else if (expectedSize == 1) { - return new Single<>(); + return new Single<>(executionContext); } else { - return new Many<>(expectedSize); + return new Many<>(expectedSize, executionContext); } } @@ -85,6 +85,12 @@ private static class Empty implements CombinedBuilder { private int ix; + private final ExecutionContext executionContext; + + public Empty(ExecutionContext executionContext) { + this.executionContext = executionContext; + } + @Override public void add(CompletableFuture completableFuture) { this.ix++; @@ -98,7 +104,8 @@ public void addObject(Object object) { @Override public CompletableFuture> await() { assertTrue(ix == 0, "expected size was 0 got %d", ix); - return typedEmpty(); +// return typedEmpty(); + return CF.completedFuture(Collections.emptyList(), executionContext); } @Override @@ -108,20 +115,26 @@ public Object awaitPolymorphic() { } // implementation details: infer the type of Completable> from a singleton empty - private static final CompletableFuture> EMPTY = CF.completedFuture(Collections.emptyList()); +// private static final CompletableFuture> EMPTY = CF.completedFuture(Collections.emptyList()); - @SuppressWarnings("unchecked") - private static CompletableFuture typedEmpty() { - return (CompletableFuture) EMPTY; - } +// @SuppressWarnings("unchecked") +// private static CompletableFuture typedEmpty() { +//// return (CompletableFuture) EMPTY; +// return CF.completedFuture(Collections.emptyList(), this.); +// } } private static class Single implements CombinedBuilder { + private final ExecutionContext executionContext; // avoiding array allocation as there is only 1 CF private Object value; private int ix; + public Single(ExecutionContext executionContext) { + this.executionContext = executionContext; + } + @Override public void add(CompletableFuture completableFuture) { this.value = completableFuture; @@ -140,10 +153,10 @@ public CompletableFuture> await() { if (value instanceof CompletableFuture) { @SuppressWarnings("unchecked") CompletableFuture cf = (CompletableFuture) value; - return CF.wrap(cf).thenApply(Collections::singletonList); + return CF.wrap(cf, executionContext).thenApply(Collections::singletonList); } //noinspection unchecked - return CF.completedFuture(Collections.singletonList((T) value)); + return CF.completedFuture(Collections.singletonList((T) value), executionContext); } @Override @@ -152,7 +165,7 @@ public Object awaitPolymorphic() { if (value instanceof CompletableFuture) { @SuppressWarnings("unchecked") CompletableFuture cf = (CompletableFuture) value; - return CF.wrap(cf).thenApply(Collections::singletonList); + return CF.wrap(cf, executionContext).thenApply(Collections::singletonList); } //noinspection unchecked return Collections.singletonList((T) value); @@ -169,8 +182,11 @@ private static class Many implements CombinedBuilder { private int ix; private int cfCount; - private Many(int size) { + final ExecutionContext executionContext; + + private Many(int size, ExecutionContext executionContext) { this.array = new Object[size]; + this.executionContext = executionContext; this.ix = 0; cfCount = 0; } @@ -194,12 +210,12 @@ public void addObject(Object object) { public CompletableFuture> await() { commonSizeAssert(); - CF> overallResult = new CF<>(); + CF> overallResult = new CF<>(executionContext); if (cfCount == 0) { overallResult.complete(materialisedList(array)); } else { CF[] cfsArr = copyOnlyCFsToArray(); - CF.allOf(cfsArr) + CF.allOf(executionContext, cfsArr) .whenComplete((ignored, exception) -> { if (exception != null) { overallResult.completeExceptionally(exception); @@ -275,12 +291,14 @@ private void commonSizeAssert() { } @SuppressWarnings("unchecked") - public static CompletableFuture> each(Collection list, Function cfOrMaterialisedValueFactory) { - Object l = eachPolymorphic(list, cfOrMaterialisedValueFactory); + public static CompletableFuture> each(Collection list, + Function cfOrMaterialisedValueFactory, + ExecutionContext executionContext) { + Object l = eachPolymorphic(list, cfOrMaterialisedValueFactory, executionContext); if (l instanceof CompletableFuture) { - return CF.wrap((CompletableFuture>) l); + return CF.wrap((CompletableFuture>) l, executionContext); } else { - return CF.completedFuture((List) l); + return CF.completedFuture((List) l, executionContext); } } @@ -296,14 +314,18 @@ public static CompletableFuture> each(Collection list, Functio * * @return a {@link CompletableFuture} to the list of resolved values or the list of values in a materialized fashion */ - public static /* CompletableFuture> | List */ Object eachPolymorphic(Collection list, Function cfOrMaterialisedValueFactory) { - CombinedBuilder futures = ofExpectedSize(list.size()); + public static /* CompletableFuture> | List */ Object eachPolymorphic(Collection list, + Function cfOrMaterialisedValueFactory, + ExecutionContext executionContext + + ) { + CombinedBuilder futures = ofExpectedSize(list.size(), executionContext); for (T t : list) { try { Object value = cfOrMaterialisedValueFactory.apply(t); futures.addObject(value); } catch (Exception e) { - CF cf = new CF<>(); + CF cf = new CF<>(executionContext); // Async.each makes sure that it is not a CompletionException inside a CompletionException cf.completeExceptionally(new CompletionException(e)); futures.add(cf); @@ -312,14 +334,16 @@ public static CompletableFuture> each(Collection list, Functio return futures.awaitPolymorphic(); } - public static CompletableFuture> eachSequentially(Iterable list, BiFunction, Object> cfOrMaterialisedValueFactory) { - CF> result = new CF<>(); - eachSequentiallyPolymorphicImpl(list.iterator(), cfOrMaterialisedValueFactory, new ArrayList<>(), result); + public static CompletableFuture> eachSequentially(Iterable list, + BiFunction, Object> cfOrMaterialisedValueFactory, + ExecutionContext executionContext) { + CF> result = new CF<>(executionContext); + eachSequentiallyPolymorphicImpl(list.iterator(), cfOrMaterialisedValueFactory, new ArrayList<>(), result, executionContext); return result; } @SuppressWarnings("unchecked") - private static void eachSequentiallyPolymorphicImpl(Iterator iterator, BiFunction, Object> cfOrMaterialisedValueFactory, List tmpResult, CompletableFuture> overallResult) { + private static void eachSequentiallyPolymorphicImpl(Iterator iterator, BiFunction, Object> cfOrMaterialisedValueFactory, List tmpResult, CompletableFuture> overallResult, ExecutionContext executionContext) { if (!iterator.hasNext()) { overallResult.complete(tmpResult); return; @@ -333,17 +357,17 @@ private static void eachSequentiallyPolymorphicImpl(Iterator iterator, } if (value instanceof CompletableFuture) { CompletableFuture cf = (CompletableFuture) value; - CF.wrap(cf).whenComplete((cfResult, exception) -> { + CF.wrap(cf, executionContext).whenComplete((cfResult, exception) -> { if (exception != null) { overallResult.completeExceptionally(exception); return; } tmpResult.add(cfResult); - eachSequentiallyPolymorphicImpl(iterator, cfOrMaterialisedValueFactory, tmpResult, overallResult); + eachSequentiallyPolymorphicImpl(iterator, cfOrMaterialisedValueFactory, tmpResult, overallResult, executionContext); }); } else { tmpResult.add((U) value); - eachSequentiallyPolymorphicImpl(iterator, cfOrMaterialisedValueFactory, tmpResult, overallResult); + eachSequentiallyPolymorphicImpl(iterator, cfOrMaterialisedValueFactory, tmpResult, overallResult, executionContext); } } @@ -357,11 +381,11 @@ private static void eachSequentiallyPolymorphicImpl(Iterator iterator, * @return a CompletableFuture */ @SuppressWarnings("unchecked") - public static CompletableFuture toCompletableFuture(Object t) { + public static CompletableFuture toCompletableFuture(Object t, ExecutionContext executionContext) { if (t instanceof CompletionStage) { - return CF.wrap(((CompletionStage) t).toCompletableFuture()); + return CF.wrap(((CompletionStage) t).toCompletableFuture(), executionContext); } else { - return CF.completedFuture((T) t); + return CF.completedFuture((T) t, executionContext); } } @@ -373,24 +397,24 @@ public static CompletableFuture toCompletableFuture(Object t) { * * @return a CompletableFuture from a CompletionStage or the materialized object itself */ - public static Object toCompletableFutureOrMaterializedObject(Object object) { + public static Object toCompletableFutureOrMaterializedObject(Object object, ExecutionContext executionContext) { if (object instanceof CompletionStage) { - return CF.wrap(((CompletionStage) object).toCompletableFuture()); + return CF.wrap(((CompletionStage) object).toCompletableFuture(), executionContext); } else { return object; } } - public static CompletableFuture tryCatch(Supplier> supplier) { + public static CompletableFuture tryCatch(Supplier> supplier, ExecutionContext executionContext) { try { return supplier.get(); } catch (Exception e) { - return exceptionallyCompletedFuture(e); + return exceptionallyCompletedFuture(e, executionContext); } } - public static CompletableFuture exceptionallyCompletedFuture(Throwable exception) { - CF result = new CF<>(); + public static CompletableFuture exceptionallyCompletedFuture(Throwable exception, ExecutionContext executionContext) { + CF result = new CF<>(executionContext); result.completeExceptionally(exception); return result; } @@ -403,7 +427,7 @@ public static CompletableFuture exceptionallyCompletedFuture(Throwable ex * * @return the completableFuture if it's not null or one that always resoles to null */ - public static @NonNull CF orNullCompletedFuture(@Nullable CompletableFuture completableFuture) { - return completableFuture != null ? CF.wrap(completableFuture) : CF.completedFuture(null); + public static @NonNull CF orNullCompletedFuture(@Nullable CompletableFuture completableFuture, ExecutionContext executionContext) { + return completableFuture != null ? CF.wrap(completableFuture, executionContext) : CF.completedFuture(null, executionContext); } } diff --git a/src/main/java/graphql/execution/AsyncExecutionStrategy.java b/src/main/java/graphql/execution/AsyncExecutionStrategy.java index 88c69c2164..e799f161ec 100644 --- a/src/main/java/graphql/execution/AsyncExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncExecutionStrategy.java @@ -50,14 +50,13 @@ public CompletableFuture execute(ExecutionContext executionCont Optional isNotSensible = Introspection.isIntrospectionSensible(fields, executionContext); if (isNotSensible.isPresent()) { - return CF.completedFuture(isNotSensible.get()); + return CF.completedFuture(isNotSensible.get(), executionContext); } DeferredExecutionSupport deferredExecutionSupport = createDeferredExecutionSupport(executionContext, parameters); Async.CombinedBuilder futures = getAsyncFieldValueInfo(executionContext, parameters, deferredExecutionSupport); - // can be waiting on DataFetcher completion, therefore it is a engine cCF - CF overallResult = new CF<>(); + CF overallResult = new CF<>(executionContext); executionStrategyCtx.onDispatched(); futures.await().whenComplete((completeValueInfos, throwable) -> { @@ -69,7 +68,7 @@ public CompletableFuture execute(ExecutionContext executionCont return; } - Async.CombinedBuilder fieldValuesFutures = Async.ofExpectedSize(completeValueInfos.size()); + Async.CombinedBuilder fieldValuesFutures = Async.ofExpectedSize(completeValueInfos.size(), executionContext); for (FieldValueInfo completeValueInfo : completeValueInfos) { fieldValuesFutures.addObject(completeValueInfo.getFieldValueObject()); } diff --git a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java index 3eea6960aa..b34ecce9a2 100644 --- a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java @@ -46,7 +46,7 @@ public CompletableFuture execute(ExecutionContext executionCont // so belts and braces Optional isNotSensible = Introspection.isIntrospectionSensible(fields, executionContext); if (isNotSensible.isPresent()) { - return CF.completedFuture(isNotSensible.get()); + return CF.completedFuture(isNotSensible.get(), executionContext); } CompletableFuture> resultsFuture = Async.eachSequentially(fieldNames, (fieldName, prevResults) -> { @@ -56,9 +56,9 @@ public CompletableFuture execute(ExecutionContext executionCont .transform(builder -> builder.field(currentField).path(fieldPath)); return resolveSerialField(executionContext, dataLoaderDispatcherStrategy, newParameters); - }); + }, executionContext); - CF overallResult = new CF<>(); + CF overallResult = new CF<>(executionContext); executionStrategyCtx.onDispatched(); resultsFuture.whenComplete(handleResults(executionContext, fieldNames, overallResult)); @@ -76,7 +76,7 @@ private Object resolveSerialField(ExecutionContext executionContext, //noinspection unchecked return ((CompletableFuture) fieldWithInfo).thenCompose(fvi -> { dataLoaderDispatcherStrategy.executionStrategyOnFieldValuesInfo(List.of(fvi)); - return fvi.getFieldValueFuture(); + return fvi.getFieldValueFuture(executionContext); }); } else { FieldValueInfo fvi = (FieldValueInfo) fieldWithInfo; diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index af83752d20..da26649dd7 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -267,7 +267,9 @@ public class CF extends CompletableFuture { volatile Object result; // Either the result or boxed AltResult volatile Completion stack; // Top of Treiber stack of dependent actions + public final ExecutionContext executionContext; + static final Map EXECUTION_RUNNING = new ConcurrentHashMap<>(); final boolean internalComplete(Object r) { // CAS from null to r boolean result = RESULT.compareAndSet(this, null, r); @@ -633,6 +635,7 @@ abstract static class UniCompletion extends Completion { Executor executor; // executor to use (null if none) CF dep; // the dependent to complete CF src; // source for action + public volatile boolean finishedRunningCode; // true if completed UniCompletion(Executor executor, CF dep, CF src) { @@ -688,16 +691,12 @@ final void unipush(Completion c) { * or returns this to caller, depending on mode. */ final CF postFire(CF a, int mode) { - if (a != null && a.stack != null) { - Object r; - if ((r = a.result) == null) { - a.cleanStack(); - } - if (mode >= 0 && (r != null || a.result != null)) { + if (a.stack != null) { + if (mode >= 0) { a.postComplete(); } } - if (result != null && stack != null) { + if (stack != null) { if (mode < 0) { return this; } else { @@ -764,7 +763,7 @@ private CF uniApplyStage( if ((r = result) != null) { return uniApplyNow(r, e, f); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); unipush(new UniApply(e, d, this, f)); return d; } @@ -772,7 +771,7 @@ private CF uniApplyStage( private CF uniApplyNow( Object r, Executor e, Function f) { Throwable x; - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); if (r instanceof AltResult) { if ((x = ((AltResult) r).ex) != null) { d.assignResult(encodeThrowable(x, r)); @@ -828,6 +827,7 @@ final CF tryFire(int mode) { } else { @SuppressWarnings("unchecked") T t = (T) r; f.accept(t); + finishedRunningCode = true; d.completeNull(); } } catch (Throwable ex) { @@ -850,7 +850,7 @@ private CF uniAcceptStage(Executor e, if ((r = result) != null) { return uniAcceptNow(r, e, f); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); unipush(new UniAccept(e, d, this, f)); return d; } @@ -858,7 +858,7 @@ private CF uniAcceptStage(Executor e, private CF uniAcceptNow( Object r, Executor e, Consumer f) { Throwable x; - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); if (r instanceof AltResult) { if ((x = ((AltResult) r).ex) != null) { d.assignResult(encodeThrowable(x, r)); @@ -931,14 +931,14 @@ private CF uniRunStage(Executor e, Runnable f) { if ((r = result) != null) { return uniRunNow(r, e, f); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); unipush(new UniRun(e, d, this, f)); return d; } private CF uniRunNow(Object r, Executor e, Runnable f) { Throwable x; - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); if (r instanceof AltResult && (x = ((AltResult) r).ex) != null) { d.assignResult(encodeThrowable(x, r)); } else { @@ -1002,6 +1002,7 @@ final boolean uniWhenComplete(Object r, t = tr; } f.accept(t, x); + if (x == null) { internalComplete(r); return true; @@ -1023,7 +1024,7 @@ private CF uniWhenCompleteStage( if (f == null) { throw new NullPointerException(); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); Object r; if ((r = result) == null) { unipush(new UniWhenComplete(e, d, this, f)); @@ -1098,7 +1099,7 @@ private CF uniHandleStage( if (f == null) { throw new NullPointerException(); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); Object r; if ((r = result) == null) { unipush(new UniHandle(e, d, this, f)); @@ -1168,7 +1169,7 @@ private CF uniExceptionallyStage( if (f == null) { throw new NullPointerException(); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); Object r; if ((r = result) == null) { unipush(new UniExceptionally(e, d, this, f)); @@ -1240,7 +1241,7 @@ private CF uniComposeExceptionallyStage( if (f == null) { throw new NullPointerException(); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); Object r, s; Throwable x; if ((r = result) == null) { @@ -1290,9 +1291,9 @@ final CF tryFire(int mode) { } private static CF uniCopyStage( - CF src) { + CF src, ExecutionContext executionContext) { Object r; - CF d = src.newIncompleteFuture(); + CF d = src.newIncompleteFuture(executionContext); if ((r = src.result) != null) { d.assignResult(encodeRelay(r)); } else { @@ -1301,15 +1302,15 @@ private static CF uniCopyStage( return d; } - private MinimalStage uniAsMinimalStage() { - Object r; - if ((r = result) != null) { - return new MinimalStage(encodeRelay(r)); - } - MinimalStage d = new MinimalStage(); - unipush(new UniRelay(d, this)); - return d; - } +// private MinimalStage uniAsMinimalStage() { +// Object r; +// if ((r = result) != null) { +// return new MinimalStage(encodeRelay(r)); +// } +// MinimalStage d = new MinimalStage(); +// unipush(new UniRelay(d, this)); +// return d; +// } @SuppressWarnings("serial") static final class UniCompose extends UniCompletion { @@ -1372,7 +1373,7 @@ private CF uniComposeStage( if (f == null) { throw new NullPointerException(); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); Object r, s; Throwable x; if ((r = result) == null) { @@ -1476,12 +1477,8 @@ final void bipush(CF b, BiCompletion c) { */ final CF postFire(CF a, CF b, int mode) { - if (b != null && b.stack != null) { // clean second source - Object r; - if ((r = b.result) == null) { - b.cleanStack(); - } - if (mode >= 0 && (r != null || b.result != null)) { + if (b.stack != null) { // clean second source + if (mode >= 0) { b.postComplete(); } } @@ -1561,7 +1558,7 @@ private CF biApplyStage( if (f == null || (b = (CF) o.toCompletableFuture()) == null) { throw new NullPointerException(); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); if ((r = result) == null || (s = b.result) == null) { bipush(b, new BiApply(e, d, this, b, f)); } else if (e == null) { @@ -1650,7 +1647,7 @@ private CF biAcceptStage( if (f == null || (b = (CF) o.toCompletableFuture()) == null) { throw new NullPointerException(); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); if ((r = result) == null || (s = b.result) == null) { bipush(b, new BiAccept(e, d, this, b, f)); } else if (e == null) { @@ -1727,7 +1724,7 @@ private CF biRunStage(Executor e, CompletionStage o, if (f == null || (b = (CF) o.toCompletableFuture()) == null) { throw new NullPointerException(); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); if ((r = result) == null || (s = b.result) == null) { bipush(b, new BiRun<>(e, d, this, b, f)); } else if (e == null) { @@ -1781,8 +1778,9 @@ final CF tryFire(int mode) { * Recursively constructs a tree of completions. */ static CF andTree(CF[] cfs, - int lo, int hi) { - CF d = new CF<>(); + int lo, int hi, + ExecutionContext executionContext) { + CF d = new CF<>(executionContext); if (lo > hi) // empty { d.assignResult(NIL); @@ -1792,9 +1790,9 @@ static CF andTree(CF[] cfs, Throwable x; int mid = (lo + hi) >>> 1; if ((a = (lo == mid ? cfs[lo] : - andTree(cfs, lo, mid))) == null || + andTree(cfs, lo, mid, executionContext))) == null || (b = (lo == hi ? a : (hi == mid + 1) ? cfs[hi] : - andTree(cfs, mid + 1, hi))) == null) { + andTree(cfs, mid + 1, hi, executionContext))) == null) { throw new NullPointerException(); } if ((r = a.result) == null || (s = b.result) == null) { @@ -1886,7 +1884,7 @@ final CF tryFire(int mode) { } private CF orApplyStage( - Executor e, CompletionStage o, Function f) { + Executor e, CompletionStage o, Function f, ExecutionContext executionContext) { CF b; if (f == null || (b = (CF) o.toCompletableFuture()) == null) { throw new NullPointerException(); @@ -1899,7 +1897,7 @@ private CF orApplyStage( return z.uniApplyNow(r, e, f); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); orpush(b, new OrApply(e, d, this, b, f)); return d; } @@ -1969,7 +1967,7 @@ private CF orAcceptStage( return z.uniAcceptNow(r, e, f); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); orpush(b, new OrAccept(e, d, this, b, f)); return d; } @@ -2034,7 +2032,7 @@ private CF orRunStage(Executor e, CompletionStage o, return z.uniRunNow(r, e, f); } - CF d = newIncompleteFuture(); + CF d = newIncompleteFuture(executionContext); orpush(b, new OrRun<>(e, d, this, b, f)); return d; } @@ -2134,11 +2132,12 @@ public void run() { } static CF asyncSupplyStage(Executor e, - Supplier f) { + Supplier f, + ExecutionContext executionContext) { if (f == null) { throw new NullPointerException(); } - CF d = new CF(); + CF d = new CF(executionContext); e.execute(new AsyncSupply(d, f)); return d; } @@ -2185,11 +2184,11 @@ public void run() { } } - static CF asyncRunStage(Executor e, Runnable f) { + static CF asyncRunStage(Executor e, Runnable f, ExecutionContext executionContext) { if (f == null) { throw new NullPointerException(); } - CF d = new CF(); + CF d = new CF(executionContext); e.execute(new AsyncRun(d, f)); return d; } @@ -2359,15 +2358,17 @@ private Object timedGet(long nanos) throws TimeoutException { /** * Creates a new incomplete CF. */ - public CF() { + public CF(ExecutionContext executionContext) { + this.executionContext = executionContext; newInstance(); } /** * Creates a new complete CF with given encoded result. */ - CF(Object r) { + CF(Object r, ExecutionContext executionContext) { this.result = r; + this.executionContext = executionContext; newInstance(); afterCompletedInternal(); } @@ -2404,8 +2405,8 @@ private void assignResult(Object r) { * * @return the new CF */ - public static CF supplyAsync(Supplier supplier) { - return asyncSupplyStage(ASYNC_POOL, supplier); + public static CF supplyAsync(Supplier supplier, ExecutionContext executionContext) { + return asyncSupplyStage(ASYNC_POOL, supplier, executionContext); } /** @@ -2421,8 +2422,9 @@ public static CF supplyAsync(Supplier supplier) { * @return the new CF */ public static CF supplyAsync(Supplier supplier, - Executor executor) { - return asyncSupplyStage(screenExecutor(executor), supplier); + Executor executor, + ExecutionContext executionContext) { + return asyncSupplyStage(screenExecutor(executor), supplier, executionContext); } /** @@ -2435,9 +2437,9 @@ public static CF supplyAsync(Supplier supplier, * * @return the new CF */ - public static CF runAsync(Runnable runnable) { - return asyncRunStage(ASYNC_POOL, runnable); - } +// public static CF runAsync(Runnable runnable,Exec) { +// return asyncRunStage(ASYNC_POOL, runnable); +// } /** * Returns a new CF that is asynchronously completed @@ -2450,10 +2452,11 @@ public static CF runAsync(Runnable runnable) { * * @return the new CF */ - public static CF runAsync(Runnable runnable, - Executor executor) { - return asyncRunStage(screenExecutor(executor), runnable); - } +// public static CF runAsync(Runnable runnable, +// Executor executor) { +// return asyncRunStage(screenExecutor(executor), runnable); +// } +// /** * Returns a new CF that is already completed with @@ -2464,8 +2467,8 @@ public static CF runAsync(Runnable runnable, * * @return the completed CF */ - public static CF completedFuture(U value) { - return new CF<>((value == null) ? NIL : value); + public static CF completedFuture(U value, ExecutionContext executionContext) { + return new CF<>((value == null) ? NIL : value, executionContext); } /** @@ -2693,19 +2696,19 @@ public CF runAfterBothAsync(CompletionStage other, } public CF applyToEither( - CompletionStage other, Function fn) { - return orApplyStage(null, other, fn); + CompletionStage other, Function fn, ExecutionContext executionContext) { + return orApplyStage(null, other, fn, executionContext); } public CF applyToEitherAsync( CompletionStage other, Function fn) { - return orApplyStage(defaultExecutor(), other, fn); + return orApplyStage(defaultExecutor(), other, fn, executionContext); } public CF applyToEitherAsync( CompletionStage other, Function fn, Executor executor) { - return orApplyStage(screenExecutor(executor), other, fn); + return orApplyStage(screenExecutor(executor), other, fn, executionContext); } public CF acceptEither( @@ -2867,62 +2870,11 @@ public CF exceptionallyComposeAsync( * @throws NullPointerException if the array or any of its elements are * {@code null} */ - public static CF allOf(CF... cfs) { - return andTree(cfs, 0, cfs.length - 1); + public static CF allOf(ExecutionContext executionContext, CF... cfs) { + return andTree(cfs, 0, cfs.length - 1, executionContext); } - /** - * Returns a new CF that is completed when any of - * the given CFs complete, with the same result. - * Otherwise, if it completed exceptionally, the returned - * CF also does so, with a CompletionException - * holding this exception as its cause. If no CFs - * are provided, returns an incomplete CF. - * - * @param cfs the CFs - * - * @return a new CF that is completed with the - * result or exception of any of the given CFs when - * one completes - * - * @throws NullPointerException if the array or any of its elements are - * {@code null} - */ - public static CF anyOf(CF... cfs) { - int n; - Object r; - if ((n = cfs.length) <= 1) { - return (n == 0) - ? new CF() - : uniCopyStage(cfs[0]); - } - for (CF cf : cfs) { - if ((r = cf.result) != null) { - return new CF(encodeRelay(r)); - } - } - cfs = cfs.clone(); - CF d = new CF<>(); - for (CF cf : cfs) { - cf.unipush(new AnyOf(d, cf, cfs)); - } - // If d was completed while we were adding completions, we should - // clean the stack of any sources that may have had completions - // pushed on their stack after d was completed. - if (d.result != null) { - for (int i = 0, len = cfs.length; i < len; i++) { - if (cfs[i].result != null) { - for (i++; i < len; i++) { - if (cfs[i].result == null) { - cfs[i].cleanStack(); - } - } - } - } - } - return d; - } /* ------------- Control and status methods -------------- */ @@ -3084,8 +3036,8 @@ private void printStackImpl(int level) { * * @since 9 */ - public CF newIncompleteFuture() { - return new CF(); + public CF newIncompleteFuture(ExecutionContext executionContext) { + return new CF(executionContext); } /** @@ -3120,7 +3072,7 @@ public Executor defaultExecutor() { * @since 9 */ public CF copy() { - return uniCopyStage(this); + return uniCopyStage(this, executionContext); } /** @@ -3143,10 +3095,10 @@ public CF copy() { * @return the new CompletionStage * * @since 9 - */ - public CompletionStage minimalCompletionStage() { - return uniAsMinimalStage(); - } + // */ +// public CompletionStage minimalCompletionStage() { +// return uniAsMinimalStage(); +// } /** * Completes this CF with the result of @@ -3294,9 +3246,9 @@ public static Executor delayedExecutor(long delay, TimeUnit unit) { * * @since 9 */ - public static CompletionStage completedStage(U value) { - return new MinimalStage((value == null) ? NIL : value); - } +// public static CompletionStage completedStage(U value) { +// return new MinimalStage((value == null) ? NIL : value); +// } /** * Returns a new CF that is already completed @@ -3309,19 +3261,20 @@ public static CompletionStage completedStage(U value) { * * @since 9 */ - public static CF failedFuture(Throwable ex) { + public static CF failedFuture(Throwable ex, ExecutionContext executionContext) { if (ex == null) { throw new NullPointerException(); } - return new CF(new AltResult(ex)); + return new CF(new AltResult(ex), executionContext); } public static CF wrap( - CompletableFuture completableFuture) { + CompletableFuture completableFuture, + ExecutionContext executionContext) { if (completableFuture instanceof CF) { return (CF) completableFuture; } - CF cf = new CF<>(); + CF cf = new CF<>(executionContext); completableFuture.whenComplete((u, ex) -> { if (ex != null) { cf.completeExceptionally(ex); @@ -3344,12 +3297,12 @@ public static CF wrap( * * @since 9 */ - public static CompletionStage failedStage(Throwable ex) { - if (ex == null) { - throw new NullPointerException(); - } - return new MinimalStage(new AltResult(ex)); - } +// public static CompletionStage failedStage(Throwable ex) { +// if (ex == null) { +// throw new NullPointerException(); +// } +// return new MinimalStage(new AltResult(ex)); +// } /** * Singleton delay scheduler, used only for starting and @@ -3470,120 +3423,120 @@ public void accept(Object ignore, Throwable ex) { /** * A subclass that just throws UOE for most non-CompletionStage methods. */ - static final class MinimalStage extends CF { - MinimalStage() { - } - - MinimalStage(Object r) { - super(r); - } - - @Override - public CF newIncompleteFuture() { - return new MinimalStage(); - } - - @Override - public T get() { - throw new UnsupportedOperationException(); - } - - @Override - public T get(long timeout, TimeUnit unit) { - throw new UnsupportedOperationException(); - } - - @Override - public T getNow(T valueIfAbsent) { - throw new UnsupportedOperationException(); - } - - @Override - public T join() { - throw new UnsupportedOperationException(); - } - - @Override - public boolean complete(T value) { - throw new UnsupportedOperationException(); - } - - @Override - public boolean completeExceptionally(Throwable ex) { - throw new UnsupportedOperationException(); - } - - @Override - public boolean cancel(boolean mayInterruptIfRunning) { - throw new UnsupportedOperationException(); - } - - @Override - public void obtrudeValue(T value) { - throw new UnsupportedOperationException(); - } - - @Override - public void obtrudeException(Throwable ex) { - throw new UnsupportedOperationException(); - } - - @Override - public boolean isDone() { - throw new UnsupportedOperationException(); - } - - @Override - public boolean isCancelled() { - throw new UnsupportedOperationException(); - } - - @Override - public boolean isCompletedExceptionally() { - throw new UnsupportedOperationException(); - } - - @Override - public int getNumberOfDependents() { - throw new UnsupportedOperationException(); - } - - @Override - public CF completeAsync - (Supplier supplier, Executor executor) { - throw new UnsupportedOperationException(); - } - - @Override - public CF completeAsync - (Supplier supplier) { - throw new UnsupportedOperationException(); - } - - @Override - public CF orTimeout - (long timeout, TimeUnit unit) { - throw new UnsupportedOperationException(); - } - - @Override - public CF completeOnTimeout - (T value, long timeout, TimeUnit unit) { - throw new UnsupportedOperationException(); - } - - @Override - public CF toCompletableFuture() { - Object r; - if ((r = result) != null) { - return new CF(encodeRelay(r)); - } else { - CF d = new CF<>(); - unipush(new UniRelay(d, this)); - return d; - } - } - } +// static final class MinimalStage extends CF { +// MinimalStage() { +// } +// +// MinimalStage(Object r) { +// super(r); +// } +// +// @Override +// public CF newIncompleteFuture() { +// return new MinimalStage(); +// } +// +// @Override +// public T get() { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public T get(long timeout, TimeUnit unit) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public T getNow(T valueIfAbsent) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public T join() { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public boolean complete(T value) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public boolean completeExceptionally(Throwable ex) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public boolean cancel(boolean mayInterruptIfRunning) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public void obtrudeValue(T value) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public void obtrudeException(Throwable ex) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public boolean isDone() { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public boolean isCancelled() { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public boolean isCompletedExceptionally() { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public int getNumberOfDependents() { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public CF completeAsync +// (Supplier supplier, Executor executor) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public CF completeAsync +// (Supplier supplier) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public CF orTimeout +// (long timeout, TimeUnit unit) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public CF completeOnTimeout +// (T value, long timeout, TimeUnit unit) { +// throw new UnsupportedOperationException(); +// } +// +// @Override +// public CF toCompletableFuture() { +// Object r; +// if ((r = result) != null) { +// return new CF(encodeRelay(r)); +// } else { +// CF d = new CF<>(); +// unipush(new UniRelay(d, this)); +// return d; +// } +// } +// } private static class DataLoaderCF extends CF { final DataFetchingEnvironment dfe; @@ -3594,6 +3547,7 @@ private static class DataLoaderCF extends CF { volatile CountDownLatch latch; public DataLoaderCF(DataFetchingEnvironment dfe, String dataLoaderName, Object key) { + super(dfe.getGraphQlContext().get(EXECUTION_CONTEXT_KEY)); this.dfe = dfe; this.dataLoaderName = dataLoaderName; this.key = key; @@ -3615,7 +3569,8 @@ public DataLoaderCF(DataFetchingEnvironment dfe, String dataLoaderName, Object k } } - DataLoaderCF() { + DataLoaderCF(ExecutionContext executionContext) { + super(executionContext); this.dfe = null; this.dataLoaderName = null; this.key = null; @@ -3625,7 +3580,12 @@ public DataLoaderCF(DataFetchingEnvironment dfe, String dataLoaderName, Object k @Override public CF newIncompleteFuture() { - return new DataLoaderCF<>(); + return new DataLoaderCF<>(executionContext); + } + + @Override + public CF newIncompleteFuture(ExecutionContext executionContext) { + return new DataLoaderCF<>(executionContext); } } diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java index eba693d2d6..12a19b6d35 100644 --- a/src/main/java/graphql/execution/ExecutionStrategy.java +++ b/src/main/java/graphql/execution/ExecutionStrategy.java @@ -215,7 +215,7 @@ protected Object executeObject(ExecutionContext executionContext, ExecutionStrat DeferredExecutionSupport deferredExecutionSupport = createDeferredExecutionSupport(executionContext, parameters); Async.CombinedBuilder resolvedFieldFutures = getAsyncFieldValueInfo(executionContext, parameters, deferredExecutionSupport); - CompletableFuture> overallResult = new CF<>(); + CompletableFuture> overallResult = new CF<>(executionContext); List fieldsExecutedOnInitialResult = deferredExecutionSupport.getNonDeferredFieldNames(fieldNames); BiConsumer, Throwable> handleResultsConsumer = buildFieldValueMap(fieldsExecutedOnInitialResult, overallResult, executionContext); @@ -230,7 +230,7 @@ protected Object executeObject(ExecutionContext executionContext, ExecutionStrat return; } - Async.CombinedBuilder resultFutures = fieldValuesCombinedBuilder(completeValueInfos); + Async.CombinedBuilder resultFutures = fieldValuesCombinedBuilder(completeValueInfos, executionContext); dataLoaderDispatcherStrategy.executeObjectOnFieldValuesInfo(completeValueInfos, parameters); resolveObjectCtx.onFieldValuesInfo(completeValueInfos); resultFutures.await().whenComplete(handleResultsConsumer); @@ -248,7 +248,7 @@ protected Object executeObject(ExecutionContext executionContext, ExecutionStrat } else { List completeValueInfos = (List) fieldValueInfosResult; - Async.CombinedBuilder resultFutures = fieldValuesCombinedBuilder(completeValueInfos); + Async.CombinedBuilder resultFutures = fieldValuesCombinedBuilder(completeValueInfos, executionContext); dataLoaderDispatcherStrategy.executeObjectOnFieldValuesInfo(completeValueInfos, parameters); resolveObjectCtx.onFieldValuesInfo(completeValueInfos); @@ -266,8 +266,8 @@ protected Object executeObject(ExecutionContext executionContext, ExecutionStrat } } - private static Async.@NonNull CombinedBuilder fieldValuesCombinedBuilder(List completeValueInfos) { - Async.CombinedBuilder resultFutures = Async.ofExpectedSize(completeValueInfos.size()); + private static Async.@NonNull CombinedBuilder fieldValuesCombinedBuilder(List completeValueInfos, ExecutionContext executionContext) { + Async.CombinedBuilder resultFutures = Async.ofExpectedSize(completeValueInfos.size(), executionContext); for (FieldValueInfo completeValueInfo : completeValueInfos) { resultFutures.addObject(completeValueInfo.getFieldValueObject()); } @@ -306,7 +306,7 @@ DeferredExecutionSupport createDeferredExecutionSupport(ExecutionContext executi fields, parameters, executionContext, - (ec, esp) -> Async.toCompletableFuture(resolveFieldWithInfo(ec, esp)) + (ec, esp) -> Async.toCompletableFuture(resolveFieldWithInfo(ec, esp), executionContext) ) : DeferredExecutionSupport.NOOP; } @@ -322,7 +322,7 @@ DeferredExecutionSupport createDeferredExecutionSupport(ExecutionContext executi // Only non-deferred fields should be considered for calculating the expected size of futures. Async.CombinedBuilder futures = Async - .ofExpectedSize(fields.size() - deferredExecutionSupport.deferredFieldsCount()); + .ofExpectedSize(fields.size() - deferredExecutionSupport.deferredFieldsCount(), executionContext); for (String fieldName : fields.getKeys()) { MergedField currentField = fields.getSubField(fieldName); @@ -360,7 +360,7 @@ DeferredExecutionSupport createDeferredExecutionSupport(ExecutionContext executi protected Object resolveField(ExecutionContext executionContext, ExecutionStrategyParameters parameters) { Object fieldWithInfo = resolveFieldWithInfo(executionContext, parameters); if (fieldWithInfo instanceof CompletableFuture) { - return ((CompletableFuture) fieldWithInfo).thenCompose(FieldValueInfo::getFieldValueFuture); + return ((CompletableFuture) fieldWithInfo).thenCompose(it -> it.getFieldValueFuture(executionContext)); } else { return ((FieldValueInfo) fieldWithInfo).getFieldValueObject(); } @@ -380,7 +380,7 @@ protected Object resolveField(ExecutionContext executionContext, ExecutionStrate * * @return a {@link CompletableFuture} promise to a {@link FieldValueInfo} or a materialised {@link FieldValueInfo} * - * @throws NonNullableFieldWasNullException in the {@link FieldValueInfo#getFieldValueFuture()} future + * @throws NonNullableFieldWasNullException in the @link FieldValueInfo#getFieldValueFuture() future * if a nonnull field resolves to a null value */ @SuppressWarnings("unchecked") @@ -411,7 +411,7 @@ protected Object resolveFieldWithInfo(ExecutionContext executionContext, Executi fieldCtx.onCompleted(fetchedValue.getFetchedValue(), null); return fieldValueInfo; } catch (Exception e) { - return Async.exceptionallyCompletedFuture(e); + return Async.exceptionallyCompletedFuture(e, executionContext); } } } @@ -502,7 +502,7 @@ private Object fetchField(GraphQLFieldDefinition fieldDef, ExecutionContext exec // if it's a subscription, leave any reactive objects alone if (!executionContext.isSubscriptionOperation()) { // possible convert reactive objects into CompletableFutures - fetchedObject = ReactiveSupport.fetchedObject(fetchedObject); + fetchedObject = ReactiveSupport.fetchedObject(fetchedObject, executionContext); } if (fetchedObject instanceof CompletableFuture) { @SuppressWarnings("unchecked") @@ -511,7 +511,7 @@ private Object fetchField(GraphQLFieldDefinition fieldDef, ExecutionContext exec .handle((result, exception) -> { fetchCtx.onCompleted(result, exception); if (exception != null) { - return handleFetchingException(dataFetchingEnvironment.get(), parameters, exception); + return handleFetchingException(dataFetchingEnvironment.get(), parameters, exception, executionContext); } else { // we can simply return the fetched value CF and avoid a allocation return fetchedValue; @@ -538,9 +538,9 @@ private Object invokeDataFetcher(ExecutionContext executionContext, ExecutionStr } else { fetchedValueRaw = dataFetcher.get(dataFetchingEnvironment.get()); } - fetchedValue = Async.toCompletableFutureOrMaterializedObject(fetchedValueRaw); + fetchedValue = Async.toCompletableFutureOrMaterializedObject(fetchedValueRaw, executionContext); } catch (Exception e) { - fetchedValue = Async.exceptionallyCompletedFuture(e); + fetchedValue = Async.exceptionallyCompletedFuture(e, executionContext); } return fetchedValue; } @@ -587,7 +587,8 @@ private void addExtensionsIfPresent(ExecutionContext executionContext, DataFetch protected CompletableFuture handleFetchingException( DataFetchingEnvironment environment, ExecutionStrategyParameters parameters, - Throwable e + Throwable e, + ExecutionContext executionContext ) { DataFetcherExceptionHandlerParameters handlerParameters = DataFetcherExceptionHandlerParameters.newExceptionParameters() .dataFetchingEnvironment(environment) @@ -595,19 +596,19 @@ protected CompletableFuture handleFetchingException( .build(); try { - return asyncHandleException(dataFetcherExceptionHandler, handlerParameters); + return asyncHandleException(dataFetcherExceptionHandler, handlerParameters, executionContext); } catch (Exception handlerException) { handlerParameters = DataFetcherExceptionHandlerParameters.newExceptionParameters() .dataFetchingEnvironment(environment) .exception(handlerException) .build(); - return asyncHandleException(new SimpleDataFetcherExceptionHandler(), handlerParameters); + return asyncHandleException(new SimpleDataFetcherExceptionHandler(), handlerParameters, executionContext); } } - private CompletableFuture asyncHandleException(DataFetcherExceptionHandler handler, DataFetcherExceptionHandlerParameters handlerParameters) { + private CompletableFuture asyncHandleException(DataFetcherExceptionHandler handler, DataFetcherExceptionHandlerParameters handlerParameters, ExecutionContext executionContext) { //noinspection unchecked - return CF.wrap(handler.handleException(handlerParameters)).thenApply( + return CF.wrap(handler.handleException(handlerParameters), executionContext).thenApply( handlerResult -> (T) DataFetcherResult.newResult().errors(handlerResult.getErrors()).build() ); } @@ -627,7 +628,7 @@ private CompletableFuture asyncHandleException(DataFetcherExceptionHandle * * @return a {@link FieldValueInfo} * - * @throws NonNullableFieldWasNullException in the {@link FieldValueInfo#getFieldValueFuture()} future + * @throws NonNullableFieldWasNullException in the @link FieldValueInfo#getFieldValueFuture(E) future * if a nonnull field resolves to a null value */ protected FieldValueInfo completeField(ExecutionContext executionContext, ExecutionStrategyParameters parameters, FetchedValue fetchedValue) { @@ -658,7 +659,7 @@ private FieldValueInfo completeField(GraphQLFieldDefinition fieldDef, ExecutionC FieldValueInfo fieldValueInfo = completeValue(executionContext, newParameters); - CompletableFuture executionResultFuture = fieldValueInfo.getFieldValueFuture(); + CompletableFuture executionResultFuture = fieldValueInfo.getFieldValueFuture(executionContext); ctxCompleteField.onDispatched(); executionResultFuture.whenComplete(ctxCompleteField::onCompleted); return fieldValueInfo; @@ -687,7 +688,7 @@ protected FieldValueInfo completeValue(ExecutionContext executionContext, Execut Object fieldValue; if (result == null) { - return getFieldValueInfoForNull(parameters); + return getFieldValueInfoForNull(parameters, executionContext); } else if (isList(fieldType)) { return completeValueForList(executionContext, parameters, result); } else if (isScalar(fieldType)) { @@ -709,7 +710,7 @@ protected FieldValueInfo completeValue(ExecutionContext executionContext, Execut // consider the result to be null and add the error on the context handleUnresolvedTypeProblem(executionContext, parameters, ex); // complete field as null, validating it is nullable - return getFieldValueInfoForNull(parameters); + return getFieldValueInfoForNull(parameters, executionContext); } return new FieldValueInfo(OBJECT, fieldValue); } @@ -729,8 +730,8 @@ private void handleUnresolvedTypeProblem(ExecutionContext context, ExecutionStra * * @throws NonNullableFieldWasNullException inside a {@link CompletableFuture} if a non null field resolves to a null value */ - private FieldValueInfo getFieldValueInfoForNull(ExecutionStrategyParameters parameters) { - Object fieldValue = completeValueForNull(parameters); + private FieldValueInfo getFieldValueInfoForNull(ExecutionStrategyParameters parameters, ExecutionContext executionContext) { + Object fieldValue = completeValueForNull(parameters, executionContext); return new FieldValueInfo(NULL, fieldValue); } @@ -744,11 +745,11 @@ private FieldValueInfo getFieldValueInfoForNull(ExecutionStrategyParameters para * @throws NonNullableFieldWasNullException inside the {@link CompletableFuture} if a non-null field resolves to a null value */ @DuckTyped(shape = "CompletableFuture | Object") - protected Object completeValueForNull(ExecutionStrategyParameters parameters) { + protected Object completeValueForNull(ExecutionStrategyParameters parameters, ExecutionContext executionContext) { try { return parameters.getNonNullFieldValidator().validate(parameters, null); } catch (Exception e) { - return Async.exceptionallyCompletedFuture(e); + return Async.exceptionallyCompletedFuture(e, executionContext); } } @@ -767,7 +768,7 @@ protected FieldValueInfo completeValueForList(ExecutionContext executionContext, try { resultIterable = parameters.getNonNullFieldValidator().validate(parameters, resultIterable); } catch (NonNullableFieldWasNullException e) { - return new FieldValueInfo(LIST, exceptionallyCompletedFuture(e)); + return new FieldValueInfo(LIST, exceptionallyCompletedFuture(e, executionContext)); } if (resultIterable == null) { return new FieldValueInfo(LIST, null); @@ -823,12 +824,12 @@ protected FieldValueInfo completeValueForList(ExecutionContext executionContext, index++; } - Object listResults = Async.eachPolymorphic(fieldValueInfos, FieldValueInfo::getFieldValueObject); + Object listResults = Async.eachPolymorphic(fieldValueInfos, FieldValueInfo::getFieldValueObject, executionContext); Object listOrPromiseToList; if (listResults instanceof CompletableFuture) { @SuppressWarnings("unchecked") CompletableFuture> resultsFuture = (CompletableFuture>) listResults; - CompletableFuture overallResult = new CF<>(); + CompletableFuture overallResult = new CF<>(executionContext); completeListCtx.onDispatched(); overallResult.whenComplete(completeListCtx::onCompleted); @@ -894,7 +895,7 @@ protected Object completeValueForScalar(ExecutionContext executionContext, Execu try { serialized = parameters.getNonNullFieldValidator().validate(parameters, serialized); } catch (NonNullableFieldWasNullException e) { - return exceptionallyCompletedFuture(e); + return exceptionallyCompletedFuture(e, executionContext); } return serialized; } @@ -920,7 +921,7 @@ protected Object completeValueForEnum(ExecutionContext executionContext, Executi try { serialized = parameters.getNonNullFieldValidator().validate(parameters, serialized); } catch (NonNullableFieldWasNullException e) { - return exceptionallyCompletedFuture(e); + return exceptionallyCompletedFuture(e, executionContext); } return serialized; } diff --git a/src/main/java/graphql/execution/FieldValueInfo.java b/src/main/java/graphql/execution/FieldValueInfo.java index 6dfc2faab0..fe76d45e44 100644 --- a/src/main/java/graphql/execution/FieldValueInfo.java +++ b/src/main/java/graphql/execution/FieldValueInfo.java @@ -1,8 +1,6 @@ package graphql.execution; import com.google.common.collect.ImmutableList; -import graphql.ExecutionResult; -import graphql.ExecutionResultImpl; import graphql.PublicApi; import java.util.List; @@ -70,8 +68,8 @@ public CompleteValueType getCompleteValueType() { * * @return a {@link CompletableFuture} promise to the value */ - public CompletableFuture getFieldValueFuture() { - return Async.toCompletableFuture(fieldValueObject); + public CompletableFuture getFieldValueFuture(ExecutionContext executionContext) { + return Async.toCompletableFuture(fieldValueObject, executionContext); } /** diff --git a/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java b/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java index fa95e86ad3..c6873ef544 100644 --- a/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java +++ b/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java @@ -107,7 +107,7 @@ private boolean keepOrdered(GraphQLContext graphQLContext) { private CompletableFuture> createSourceEventStream(ExecutionContext executionContext, ExecutionStrategyParameters parameters) { ExecutionStrategyParameters newParameters = firstFieldOfSubscriptionSelection(parameters); - CompletableFuture fieldFetched = Async.toCompletableFuture(fetchField(executionContext, newParameters)); + CompletableFuture fieldFetched = Async.toCompletableFuture(fetchField(executionContext, newParameters), executionContext); return fieldFetched.thenApply(fetchedValue -> { Object publisher = fetchedValue.getFetchedValue(); if (publisher != null) { @@ -149,7 +149,7 @@ private CompletableFuture executeSubscriptionEvent(ExecutionCon FetchedValue fetchedValue = unboxPossibleDataFetcherResult(newExecutionContext, parameters, eventPayload); FieldValueInfo fieldValueInfo = completeField(newExecutionContext, newParameters, fetchedValue); CompletableFuture overallResult = fieldValueInfo - .getFieldValueFuture() + .getFieldValueFuture(executionContext) .thenApply(val -> new ExecutionResultImpl(val, newExecutionContext.getErrors())) .thenApply(executionResult -> wrapWithRootFieldName(newParameters, executionResult)); @@ -161,7 +161,7 @@ private CompletableFuture executeSubscriptionEvent(ExecutionCon InstrumentationExecutionParameters i13nExecutionParameters = new InstrumentationExecutionParameters( executionContext.getExecutionInput(), executionContext.getGraphQLSchema()); - overallResult = overallResult.thenCompose(executionResult -> CF.wrap(instrumentation.instrumentExecutionResult(executionResult, i13nExecutionParameters, executionContext.getInstrumentationState()))); + overallResult = overallResult.thenCompose(executionResult -> CF.wrap(instrumentation.instrumentExecutionResult(executionResult, i13nExecutionParameters, executionContext.getInstrumentationState()), executionContext)); return overallResult; } diff --git a/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java b/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java index 3b8e7efe8a..425c1d0367 100644 --- a/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java +++ b/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java @@ -124,7 +124,8 @@ private DeferredFragmentCall createDeferredFragmentCall(DeferredExecution deferr deferredExecution.getLabel(), this.parameters.getPath(), calls, - deferredCallContext + deferredCallContext, + executionContext ); } @@ -165,7 +166,7 @@ private Supplier ExecutionResultImpl.newExecutionResult().data(fv).build()); } ); diff --git a/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java b/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java index e09acae3b9..f4ecd6f679 100644 --- a/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java +++ b/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java @@ -6,6 +6,7 @@ import graphql.Internal; import graphql.execution.Async; import graphql.execution.CF; +import graphql.execution.ExecutionContext; import graphql.execution.NonNullableFieldWasNullError; import graphql.execution.NonNullableFieldWasNullException; import graphql.execution.ResultPath; @@ -48,26 +49,29 @@ public ResultPath getPath() { private final ResultPath path; private final List>> calls; private final DeferredCallContext deferredCallContext; + private final ExecutionContext executionContext; public DeferredFragmentCall( String label, ResultPath path, List>> calls, - DeferredCallContext deferredCallContext + DeferredCallContext deferredCallContext, + ExecutionContext executionContext ) { this.label = label; this.path = path; this.calls = calls; this.deferredCallContext = deferredCallContext; + this.executionContext = executionContext; } @Override public CompletableFuture invoke() { - Async.CombinedBuilder futures = Async.ofExpectedSize(calls.size()); + Async.CombinedBuilder futures = Async.ofExpectedSize(calls.size(), executionContext); calls.forEach(call -> { CompletableFuture cf = call.get(); - futures.add(CF.wrap(cf)); + futures.add(CF.wrap(cf, executionContext)); }); return futures.await() diff --git a/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java b/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java index 10b5c287e9..cb61b62959 100644 --- a/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java @@ -34,6 +34,7 @@ import java.util.function.BiFunction; import static graphql.Assert.assertNotNull; +import static graphql.execution.Execution.EXECUTION_CONTEXT_KEY; /** * This allows you to chain together a number of {@link graphql.execution.instrumentation.Instrumentation} implementations @@ -251,12 +252,14 @@ public DataFetcher instrumentDataFetcher(DataFetcher dataFetcher, Instrume @Override public CompletableFuture instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) { ImmutableList> entries = chainedMapAndDropNulls(state, AbstractMap.SimpleEntry::new); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(EXECUTION_CONTEXT_KEY); CompletableFuture> resultsFuture = Async.eachSequentially(entries, (entry, prevResults) -> { Instrumentation instrumentation = entry.getKey(); InstrumentationState specificState = entry.getValue(); ExecutionResult lastResult = !prevResults.isEmpty() ? prevResults.get(prevResults.size() - 1) : executionResult; - return CF.wrap(instrumentation.instrumentExecutionResult(lastResult, parameters, specificState)); - }); + + return CF.wrap(instrumentation.instrumentExecutionResult(lastResult, parameters, specificState), executionContext); + }, executionContext); return resultsFuture.thenApply((results) -> results.isEmpty() ? executionResult : results.get(results.size() - 1)); } @@ -272,10 +275,11 @@ private InstrumentationState getState(int index) { } private static CompletableFuture combineAll(List instrumentations, InstrumentationCreateStateParameters parameters) { - Async.CombinedBuilder builder = Async.ofExpectedSize(instrumentations.size()); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(EXECUTION_CONTEXT_KEY); + Async.CombinedBuilder builder = Async.ofExpectedSize(instrumentations.size(), executionContext); for (Instrumentation instrumentation : instrumentations) { // state can be null including the CF so handle that - CompletableFuture stateCF = Async.orNullCompletedFuture(instrumentation.createStateAsync(parameters)); + CompletableFuture stateCF = Async.orNullCompletedFuture(instrumentation.createStateAsync(parameters), executionContext); builder.add(stateCF); } return builder.await().thenApply(ChainedInstrumentationState::new); diff --git a/src/main/java/graphql/execution/instrumentation/Instrumentation.java b/src/main/java/graphql/execution/instrumentation/Instrumentation.java index f5f8a52bf3..240dd21924 100644 --- a/src/main/java/graphql/execution/instrumentation/Instrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/Instrumentation.java @@ -5,6 +5,7 @@ import graphql.ExperimentalApi; import graphql.PublicSpi; import graphql.execution.CF; +import graphql.execution.Execution; import graphql.execution.ExecutionContext; import graphql.execution.instrumentation.parameters.InstrumentationCreateStateParameters; import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters; @@ -52,7 +53,8 @@ public interface Instrumentation { @Nullable default CompletableFuture createStateAsync(InstrumentationCreateStateParameters parameters) { InstrumentationState state = createState(parameters); - return state == null ? null : CF.completedFuture(state); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return state == null ? null : CF.completedFuture(state, executionContext); } /** @@ -340,6 +342,7 @@ default DataFetcher instrumentDataFetcher(DataFetcher dataFetcher, Instrum */ @NonNull default CompletableFuture instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) { - return CF.completedFuture(executionResult); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return CF.completedFuture(executionResult, executionContext); } } diff --git a/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java b/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java index cafe855150..d2418e34f9 100644 --- a/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java @@ -4,6 +4,7 @@ import graphql.ExecutionResult; import graphql.PublicApi; import graphql.execution.CF; +import graphql.execution.Execution; import graphql.execution.ExecutionContext; import graphql.execution.instrumentation.parameters.InstrumentationCreateStateParameters; import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters; @@ -49,7 +50,8 @@ public class SimplePerformantInstrumentation implements Instrumentation { @Override public @Nullable CompletableFuture createStateAsync(InstrumentationCreateStateParameters parameters) { InstrumentationState state = createState(parameters); - return state == null ? null : CF.completedFuture(state); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return state == null ? null : CF.completedFuture(state, executionContext); } @Override @@ -139,6 +141,7 @@ public class SimplePerformantInstrumentation implements Instrumentation { @Override public @NonNull CompletableFuture instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) { - return CF.completedFuture(executionResult); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return CF.completedFuture(executionResult, executionContext); } } diff --git a/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java b/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java index 0893805fc6..3252d2e097 100644 --- a/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/threadpools/ExecutorInstrumentation.java @@ -1,167 +1,167 @@ -package graphql.execution.instrumentation.threadpools; - -import com.google.common.annotations.Beta; -import graphql.Assert; -import graphql.Internal; -import graphql.TrivialDataFetcher; -import graphql.execution.Async; -import graphql.execution.CF; -import graphql.execution.instrumentation.InstrumentationState; -import graphql.execution.instrumentation.SimplePerformantInstrumentation; -import graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters; -import graphql.schema.DataFetcher; -import graphql.schema.DataFetchingEnvironment; -import org.jspecify.annotations.NonNull; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.Executor; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.Supplier; - -import static graphql.execution.instrumentation.threadpools.ExecutorInstrumentation.Action.FETCHING; -import static graphql.execution.instrumentation.threadpools.ExecutorInstrumentation.Action.PROCESSING; - -/** - * This instrumentation can be used to control on what thread calls to {@link DataFetcher}s happen on. - *

- * If your data fetching is inherently IO bound then you could use a IO oriented thread pool for your fetches and transfer control - * back to a CPU oriented thread pool and allow graphql-java code to run the post-processing of results there. - *

- * An IO oriented thread pool is typically a multiple of {@link Runtime#availableProcessors()} while a CPU oriented thread pool - * is typically no more than {@link Runtime#availableProcessors()}. - *

- * The instrumentation will use the {@link graphql.execution.instrumentation.Instrumentation#instrumentDataFetcher(DataFetcher, InstrumentationFieldFetchParameters, InstrumentationState)} - * method to change your data fetchers, so they are executed on a thread pool dedicated to fetching (if you provide one). - *

- * Once the data fetcher value is returns it will transfer control back to a processing thread pool (if you provide one). - *

- * This code uses {@link CompletableFuture#supplyAsync(Supplier, Executor)} and {@link CompletableFuture#thenApplyAsync(Function, Executor)} to transfer - * control between thread pools. - */ -@Internal -@Beta -public class ExecutorInstrumentation extends SimplePerformantInstrumentation { - - private static final Consumer NOOP = a -> { - }; - - /** - * This describes what action is currently being done. This is mostly intended for testing. - */ - enum Action {FETCHING, PROCESSING} - - private final Executor fetchExecutor; - private final Executor processingExecutor; - private final Consumer actionObserver; - - private ExecutorInstrumentation(Executor fetchExecutor, Executor processingExecutor, Consumer actionObserver) { - this.fetchExecutor = fetchExecutor; - this.processingExecutor = processingExecutor; - this.actionObserver = actionObserver; - } - - public Executor getFetchExecutor() { - return fetchExecutor; - } - - public Executor getProcessingExecutor() { - return processingExecutor; - } - - public static Builder newThreadPoolExecutionInstrumentation() { - return new Builder(); - } - - public static class Builder { - Executor fetchExecutor; - Executor processingExecutor; - private Consumer actionObserver; - - public Builder fetchExecutor(Executor fetchExecutor) { - this.fetchExecutor = fetchExecutor; - return this; - } - - public Builder processingExecutor(Executor processingExecutor) { - this.processingExecutor = processingExecutor; - return this; - } - - /** - * This is really intended for testing but this consumer will be called during - * stages to indicate what is happening. - * - * @param actionObserver the observer code - * - * @return this builder - */ - public Builder actionObserver(Consumer actionObserver) { - this.actionObserver = Assert.assertNotNull(actionObserver); - return this; - } - - public ExecutorInstrumentation build() { - return new ExecutorInstrumentation(fetchExecutor, processingExecutor, actionObserver != null ? actionObserver : NOOP); - } - - } - - @Override - public @NonNull DataFetcher instrumentDataFetcher(DataFetcher originalDataFetcher, InstrumentationFieldFetchParameters parameters, InstrumentationState state) { - if (originalDataFetcher instanceof TrivialDataFetcher) { - return originalDataFetcher; - } - return environment -> { - CompletableFuture> invokedCF; - if (fetchExecutor != null) { - // run the fetch asynchronously via the fetch executor - // the CF will be left running on that fetch executors thread - invokedCF = CompletableFuture.supplyAsync(invokedAsync(originalDataFetcher, environment), fetchExecutor); - } else { - invokedCF = invokedSync(originalDataFetcher, environment); - } - if (processingExecutor != null) { - invokedCF = invokedCF.thenApplyAsync(processingControl(), processingExecutor); - } else { - invokedCF = invokedCF.thenApply(processingControl()); - } - return invokedCF.thenCompose(cs -> cs); - }; - } - - - private Supplier> invokedAsync(DataFetcher originalDataFetcher, DataFetchingEnvironment environment) { - return () -> { - actionObserver.accept(FETCHING); - return invokeOriginalDF(originalDataFetcher, environment); - }; - } - - private CompletableFuture> invokedSync(DataFetcher originalDataFetcher, DataFetchingEnvironment environment) { - actionObserver.accept(FETCHING); - return CF.completedFuture(invokeOriginalDF(originalDataFetcher, environment)); - } - - private Function, CompletionStage> processingControl() { - return completionStage -> { - actionObserver.accept(PROCESSING); - return completionStage; - }; - } - - private CompletionStage invokeOriginalDF(DataFetcher originalDataFetcher, DataFetchingEnvironment environment) { - Object value; - try { - value = originalDataFetcher.get(environment); - } catch (Exception e) { - return Async.exceptionallyCompletedFuture(e); - } - if (value instanceof CompletionStage) { - return ((CompletionStage) value); - } else { - return CF.completedFuture(value); - } - } -} +//package graphql.execution.instrumentation.threadpools; +// +//import com.google.common.annotations.Beta; +//import graphql.Assert; +//import graphql.Internal; +//import graphql.TrivialDataFetcher; +//import graphql.execution.Async; +//import graphql.execution.CF; +//import graphql.execution.instrumentation.InstrumentationState; +//import graphql.execution.instrumentation.SimplePerformantInstrumentation; +//import graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters; +//import graphql.schema.DataFetcher; +//import graphql.schema.DataFetchingEnvironment; +//import org.jspecify.annotations.NonNull; +// +//import java.util.concurrent.CompletableFuture; +//import java.util.concurrent.CompletionStage; +//import java.util.concurrent.Executor; +//import java.util.function.Consumer; +//import java.util.function.Function; +//import java.util.function.Supplier; +// +//import static graphql.execution.instrumentation.threadpools.ExecutorInstrumentation.Action.FETCHING; +//import static graphql.execution.instrumentation.threadpools.ExecutorInstrumentation.Action.PROCESSING; +// +/// ** +// * This instrumentation can be used to control on what thread calls to {@link DataFetcher}s happen on. +// *

+// * If your data fetching is inherently IO bound then you could use a IO oriented thread pool for your fetches and transfer control +// * back to a CPU oriented thread pool and allow graphql-java code to run the post-processing of results there. +// *

+// * An IO oriented thread pool is typically a multiple of {@link Runtime#availableProcessors()} while a CPU oriented thread pool +// * is typically no more than {@link Runtime#availableProcessors()}. +// *

+// * The instrumentation will use the {@link graphql.execution.instrumentation.Instrumentation#instrumentDataFetcher(DataFetcher, InstrumentationFieldFetchParameters, InstrumentationState)} +// * method to change your data fetchers, so they are executed on a thread pool dedicated to fetching (if you provide one). +// *

+// * Once the data fetcher value is returns it will transfer control back to a processing thread pool (if you provide one). +// *

+// * This code uses {@link CompletableFuture#supplyAsync(Supplier, Executor)} and {@link CompletableFuture#thenApplyAsync(Function, Executor)} to transfer +// * control between thread pools. +// */ +//@Internal +//@Beta +//public class ExecutorInstrumentation extends SimplePerformantInstrumentation { +// +// private static final Consumer NOOP = a -> { +// }; +// +// /** +// * This describes what action is currently being done. This is mostly intended for testing. +// */ +// enum Action {FETCHING, PROCESSING} +// +// private final Executor fetchExecutor; +// private final Executor processingExecutor; +// private final Consumer actionObserver; +// +// private ExecutorInstrumentation(Executor fetchExecutor, Executor processingExecutor, Consumer actionObserver) { +// this.fetchExecutor = fetchExecutor; +// this.processingExecutor = processingExecutor; +// this.actionObserver = actionObserver; +// } +// +// public Executor getFetchExecutor() { +// return fetchExecutor; +// } +// +// public Executor getProcessingExecutor() { +// return processingExecutor; +// } +// +// public static Builder newThreadPoolExecutionInstrumentation() { +// return new Builder(); +// } +// +// public static class Builder { +// Executor fetchExecutor; +// Executor processingExecutor; +// private Consumer actionObserver; +// +// public Builder fetchExecutor(Executor fetchExecutor) { +// this.fetchExecutor = fetchExecutor; +// return this; +// } +// +// public Builder processingExecutor(Executor processingExecutor) { +// this.processingExecutor = processingExecutor; +// return this; +// } +// +// /** +// * This is really intended for testing but this consumer will be called during +// * stages to indicate what is happening. +// * +// * @param actionObserver the observer code +// * +// * @return this builder +// */ +// public Builder actionObserver(Consumer actionObserver) { +// this.actionObserver = Assert.assertNotNull(actionObserver); +// return this; +// } +// +// public ExecutorInstrumentation build() { +// return new ExecutorInstrumentation(fetchExecutor, processingExecutor, actionObserver != null ? actionObserver : NOOP); +// } +// +// } +// +// @Override +// public @NonNull DataFetcher instrumentDataFetcher(DataFetcher originalDataFetcher, InstrumentationFieldFetchParameters parameters, InstrumentationState state) { +// if (originalDataFetcher instanceof TrivialDataFetcher) { +// return originalDataFetcher; +// } +// return environment -> { +// CompletableFuture> invokedCF; +// if (fetchExecutor != null) { +// // run the fetch asynchronously via the fetch executor +// // the CF will be left running on that fetch executors thread +// invokedCF = CompletableFuture.supplyAsync(invokedAsync(originalDataFetcher, environment), fetchExecutor); +// } else { +// invokedCF = invokedSync(originalDataFetcher, environment); +// } +// if (processingExecutor != null) { +// invokedCF = invokedCF.thenApplyAsync(processingControl(), processingExecutor); +// } else { +// invokedCF = invokedCF.thenApply(processingControl()); +// } +// return invokedCF.thenCompose(cs -> cs); +// }; +// } +// +// +// private Supplier> invokedAsync(DataFetcher originalDataFetcher, DataFetchingEnvironment environment) { +// return () -> { +// actionObserver.accept(FETCHING); +// return invokeOriginalDF(originalDataFetcher, environment); +// }; +// } +// +// private CompletableFuture> invokedSync(DataFetcher originalDataFetcher, DataFetchingEnvironment environment) { +// actionObserver.accept(FETCHING); +// return CF.completedFuture(invokeOriginalDF(originalDataFetcher, environment)); +// } +// +// private Function, CompletionStage> processingControl() { +// return completionStage -> { +// actionObserver.accept(PROCESSING); +// return completionStage; +// }; +// } +// +// private CompletionStage invokeOriginalDF(DataFetcher originalDataFetcher, DataFetchingEnvironment environment) { +// Object value; +// try { +// value = originalDataFetcher.get(environment); +// } catch (Exception e) { +// return Async.exceptionallyCompletedFuture(e); +// } +// if (value instanceof CompletionStage) { +// return ((CompletionStage) value); +// } else { +// return CF.completedFuture(value); +// } +// } +//} diff --git a/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java b/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java index 238d368001..c6b166477f 100644 --- a/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java +++ b/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java @@ -5,6 +5,8 @@ import graphql.PublicApi; import graphql.collect.ImmutableKit; import graphql.execution.CF; +import graphql.execution.Execution; +import graphql.execution.ExecutionContext; import graphql.execution.instrumentation.Instrumentation; import graphql.execution.instrumentation.InstrumentationContext; import graphql.execution.instrumentation.InstrumentationState; @@ -74,7 +76,8 @@ public TracingInstrumentation(Options options) { @Override public @Nullable CompletableFuture createStateAsync(InstrumentationCreateStateParameters parameters) { - return CF.completedFuture(new TracingSupport(options.includeTrivialDataFetchers)); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return CF.completedFuture(new TracingSupport(options.includeTrivialDataFetchers), executionContext); } @Override @@ -85,7 +88,8 @@ public TracingInstrumentation(Options options) { Map withTracingExt = new LinkedHashMap<>(currentExt == null ? ImmutableKit.emptyMap() : currentExt); withTracingExt.put("tracing", tracingSupport.snapshotTracingData()); - return CF.completedFuture(new ExecutionResultImpl(executionResult.getData(), executionResult.getErrors(), withTracingExt)); + ExecutionContext executionContext = parameters.getExecutionInput().getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return CF.completedFuture(new ExecutionResultImpl(executionResult.getData(), executionResult.getErrors(), withTracingExt), executionContext); } @Override diff --git a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java index ffe67b10eb..aa64884c49 100644 --- a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java +++ b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java @@ -4,6 +4,8 @@ import graphql.ExecutionInput; import graphql.Internal; import graphql.execution.CF; +import graphql.execution.Execution; +import graphql.execution.ExecutionContext; import java.util.concurrent.CompletableFuture; import java.util.function.Function; @@ -14,6 +16,7 @@ public class NoOpPreparsedDocumentProvider implements PreparsedDocumentProvider @Override public CompletableFuture getDocumentAsync(ExecutionInput executionInput, Function parseAndValidateFunction) { - return CF.completedFuture(parseAndValidateFunction.apply(executionInput)); + ExecutionContext executionContext = executionInput.getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return CF.completedFuture(parseAndValidateFunction.apply(executionInput), executionContext); } } diff --git a/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java b/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java index 65c10c03c7..0b952c3c82 100644 --- a/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java +++ b/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java @@ -4,6 +4,8 @@ import graphql.ExecutionInput; import graphql.PublicApi; import graphql.execution.CF; +import graphql.execution.Execution; +import graphql.execution.ExecutionContext; import graphql.execution.preparsed.PreparsedDocumentEntry; import java.util.HashMap; @@ -47,7 +49,8 @@ public CompletableFuture getPersistedQueryDocumentAsync( } return onCacheMiss.apply(queryText); }); - return CF.completedFuture(documentEntry); + ExecutionContext executionContext = executionInput.getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); + return CF.completedFuture(documentEntry, executionContext); } public static Builder newInMemoryPersistedQueryCache() { diff --git a/src/main/java/graphql/execution/preparsed/persisted/PersistedQuerySupport.java b/src/main/java/graphql/execution/preparsed/persisted/PersistedQuerySupport.java index 607ce3f813..09bbb29146 100644 --- a/src/main/java/graphql/execution/preparsed/persisted/PersistedQuerySupport.java +++ b/src/main/java/graphql/execution/preparsed/persisted/PersistedQuerySupport.java @@ -5,6 +5,8 @@ import graphql.GraphqlErrorBuilder; import graphql.PublicSpi; import graphql.execution.CF; +import graphql.execution.Execution; +import graphql.execution.ExecutionContext; import graphql.execution.preparsed.PreparsedDocumentEntry; import graphql.execution.preparsed.PreparsedDocumentProvider; @@ -42,6 +44,7 @@ public CompletableFuture getDocumentAsync(ExecutionInput Optional queryIdOption = getPersistedQueryId(executionInput); assertNotNull(queryIdOption, "The class %s MUST return a non null optional query id", this.getClass().getName()); + ExecutionContext executionContext = executionInput.getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); try { if (queryIdOption.isPresent()) { Object persistedQueryId = queryIdOption.get(); @@ -59,9 +62,9 @@ public CompletableFuture getDocumentAsync(ExecutionInput }); } // ok there is no query id - we assume the query is indeed ready to go as is - ie its not a persisted query - return CF.completedFuture(parseAndValidateFunction.apply(executionInput)); + return CF.completedFuture(parseAndValidateFunction.apply(executionInput), executionContext); } catch (PersistedQueryError e) { - return CF.completedFuture(mkMissingError(e)); + return CF.completedFuture(mkMissingError(e), executionContext); } } diff --git a/src/main/java/graphql/execution/reactive/ReactiveSupport.java b/src/main/java/graphql/execution/reactive/ReactiveSupport.java index 7c08eca78f..4885203371 100644 --- a/src/main/java/graphql/execution/reactive/ReactiveSupport.java +++ b/src/main/java/graphql/execution/reactive/ReactiveSupport.java @@ -3,6 +3,7 @@ import graphql.DuckTyped; import graphql.Internal; import graphql.execution.CF; +import graphql.execution.ExecutionContext; import org.reactivestreams.Publisher; import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; @@ -22,26 +23,26 @@ public class ReactiveSupport { @DuckTyped(shape = "CompletableFuture | Object") - public static Object fetchedObject(Object fetchedObject) { + public static Object fetchedObject(Object fetchedObject, ExecutionContext executionContext) { if (fetchedObject instanceof Flow.Publisher) { - return flowPublisherToCF((Flow.Publisher) fetchedObject); + return flowPublisherToCF((Flow.Publisher) fetchedObject, executionContext); } if (fetchedObject instanceof Publisher) { - return reactivePublisherToCF((Publisher) fetchedObject); + return reactivePublisherToCF((Publisher) fetchedObject, executionContext); } return fetchedObject; } - private static CompletableFuture reactivePublisherToCF(Publisher publisher) { + private static CompletableFuture reactivePublisherToCF(Publisher publisher, ExecutionContext executionContext) { ReactivePublisherToCompletableFuture cf = new ReactivePublisherToCompletableFuture<>(); publisher.subscribe(cf); - return CF.wrap(cf); + return CF.wrap(cf, executionContext); } - private static CompletableFuture flowPublisherToCF(Flow.Publisher publisher) { + private static CompletableFuture flowPublisherToCF(Flow.Publisher publisher, ExecutionContext executionContext) { FlowPublisherToCompletableFuture cf = new FlowPublisherToCompletableFuture<>(); publisher.subscribe(cf); - return CF.wrap(cf); + return CF.wrap(cf, executionContext); } /** diff --git a/src/test/groovy/graphql/execution/BreadthFirstExecutionTestStrategy.java b/src/test/groovy/graphql/execution/BreadthFirstExecutionTestStrategy.java index c01426353f..49128ca8af 100644 --- a/src/test/groovy/graphql/execution/BreadthFirstExecutionTestStrategy.java +++ b/src/test/groovy/graphql/execution/BreadthFirstExecutionTestStrategy.java @@ -58,11 +58,11 @@ private FetchedValue fetchField(ExecutionContext executionContext, ExecutionStra ExecutionStrategyParameters newParameters = parameters .transform(builder -> builder.field(currentField).path(fieldPath)); - return Async.toCompletableFuture(fetchField(executionContext, newParameters)).join(); + return Async.toCompletableFuture(fetchField(executionContext, newParameters), executionContext).join(); } private void completeValue(ExecutionContext executionContext, Map results, String fieldName, FetchedValue fetchedValue, ExecutionStrategyParameters newParameters) { - Object resolvedResult = completeField(executionContext, newParameters, fetchedValue).getFieldValueFuture().join(); + Object resolvedResult = completeField(executionContext, newParameters, fetchedValue).getFieldValueFuture(executionContext).join(); results.put(fieldName, resolvedResult); } diff --git a/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java b/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java index 6c8aa262db..9c7b7477bc 100644 --- a/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java +++ b/src/test/groovy/graphql/execution/BreadthFirstTestStrategy.java @@ -41,12 +41,12 @@ private Map fetchFields(ExecutionContext executionContext, for (String fieldName : fields.keySet()) { ExecutionStrategyParameters newParameters = newParameters(parameters, fields, fieldName); - CF fetchFuture = (CF) Async.toCompletableFuture(fetchField(executionContext, newParameters)); + CF fetchFuture = (CF) Async.toCompletableFuture(fetchField(executionContext, newParameters), executionContext); fetchFutures.put(fieldName, fetchFuture); } // now wait for all fetches to finish together via this join - allOf(fetchFutures.values()).join(); + allOf(fetchFutures.values(), executionContext).join(); Map fetchedValues = new LinkedHashMap<>(); fetchFutures.forEach((k, v) -> fetchedValues.put(k, v.join())); @@ -63,7 +63,7 @@ private CompletableFuture completeFields(ExecutionContext execu FetchedValue fetchedValue = fetchedValues.get(fieldName); try { - Object resolvedResult = completeField(executionContext, newParameters, fetchedValue).getFieldValueFuture().join(); + Object resolvedResult = completeField(executionContext, newParameters, fetchedValue).getFieldValueFuture(executionContext).join(); results.put(fieldName, resolvedResult); } catch (NonNullableFieldWasNullException e) { assertNonNullFieldPrecondition(e); @@ -82,10 +82,10 @@ private ExecutionStrategyParameters newParameters(ExecutionStrategyParameters pa } - public static CF> allOf(final Collection> futures) { + public static CF> allOf(final Collection> futures, ExecutionContext executionContext) { CF[] cfs = futures.toArray(new CF[futures.size()]); - return CF.allOf(cfs) + return CF.allOf(executionContext, cfs) .thenApply(vd -> futures.stream() .map(CompletableFuture::join) .collect(Collectors.toList()) diff --git a/src/test/groovy/graphql/execution/instrumentation/threadpools/ExecutorInstrumentationTest.groovy b/src/test/groovy/graphql/execution/instrumentation/threadpools/ExecutorInstrumentationTest.groovy index c9c31d2323..d079afae51 100644 --- a/src/test/groovy/graphql/execution/instrumentation/threadpools/ExecutorInstrumentationTest.groovy +++ b/src/test/groovy/graphql/execution/instrumentation/threadpools/ExecutorInstrumentationTest.groovy @@ -1,214 +1,214 @@ -package graphql.execution.instrumentation.threadpools - - -import graphql.TestUtil -import graphql.schema.DataFetcher -import graphql.schema.DataFetchingEnvironment -import graphql.schema.DataFetchingEnvironmentImpl -import graphql.schema.PropertyDataFetcher -import spock.lang.Ignore -import spock.lang.Specification - -import java.util.concurrent.CompletableFuture -import java.util.concurrent.Executor -import java.util.concurrent.Executors -import java.util.concurrent.ThreadFactory -import java.util.function.Consumer - -import static ExecutorInstrumentation.Action -import static java.lang.Thread.currentThread - -@Ignore -class ExecutorInstrumentationTest extends Specification { - - private static ThreadFactory threadFactory(String name) { - new ThreadFactory() { - @Override - Thread newThread(Runnable r) { - return new Thread(r, name) - } - } - } - - static class TestingObserver implements Consumer { - def actions = [] - - @Override - void accept(Action action) { - actions.add(action.toString() + " on " + currentThread().getName()) - } - } - - def FetchExecutor = Executors.newSingleThreadExecutor(threadFactory("FetchThread")) - def ProcessingExecutor = Executors.newSingleThreadExecutor(threadFactory("ProcessingThread")) - - ExecutorInstrumentation instrumentation - def observer = new TestingObserver() - - - ExecutorInstrumentation build(Executor fetchExecutor, Executor processingExecutor, Consumer observer) { - def builder = ExecutorInstrumentation.newThreadPoolExecutionInstrumentation() - if (fetchExecutor != null) { - builder.fetchExecutor(fetchExecutor) - } - if (processingExecutor != null) { - builder.processingExecutor(processingExecutor) - } - builder.actionObserver(observer).build() - } - - DataFetchingEnvironment dfEnv(Object s) { - DataFetchingEnvironmentImpl.newDataFetchingEnvironment().source(s).build() - } - - CompletableFuture asCF(returnedValue) { - (CompletableFuture) returnedValue - } - - void setup() { - observer = new TestingObserver() - instrumentation = build(FetchExecutor, ProcessingExecutor, observer) - } - - def "basic building works"() { - expect: - instrumentation.getFetchExecutor() == FetchExecutor - instrumentation.getProcessingExecutor() == ProcessingExecutor - } - - def "can handle a data fetcher that throws exceptions"() { - when: - DataFetcher df = { env -> throw new RuntimeException("BANG") } - def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null,null) - def returnedValue = modifiedDataFetcher.get(null) - - then: - returnedValue instanceof CompletableFuture - - when: - asCF(returnedValue).join() - - then: - def e = thrown(RuntimeException) - e.getMessage().contains("BANG") - } - - - def "will leave trivial data fetchers as is"() { - - when: - DataFetcher df = PropertyDataFetcher.fetching({ o -> "trivial" }) - def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null,null) - def returnedValue = modifiedDataFetcher.get(dfEnv("source")) - - then: - modifiedDataFetcher == df - returnedValue == "trivial" - } - - - def "will execute on another thread and transfer execution back to the processing thread"() { - - when: - instrumentation = build(FetchExecutor, ProcessingExecutor, observer) - - DataFetcher df = { env -> currentThread().getName() } - def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null, null) - def returnedValue = modifiedDataFetcher.get(null) - - then: - returnedValue instanceof CompletableFuture - - when: - def value = asCF(returnedValue).join() - - then: - value == "FetchThread" - observer.actions == ["FETCHING on FetchThread", "PROCESSING on ProcessingThread"] - } - - @Ignore("This test is flaky on GitHub pipelines") - def "will execute on another thread and stay there without a processing executor"() { - - when: - instrumentation = build(FetchExecutor, null, observer) - - DataFetcher df = { env -> currentThread().getName() } - def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null, null) - def returnedValue = modifiedDataFetcher.get(null) - - then: - returnedValue instanceof CompletableFuture - - when: - def value = asCF(returnedValue).join() - - then: - value == "FetchThread" - observer.actions == ["FETCHING on FetchThread", "PROCESSING on FetchThread"] - } - - def "will fetch on current thread if the executor is null but transfer control back"() { - - when: - def currentThreadName = currentThread().getName() - instrumentation = build(null, ProcessingExecutor, observer) - - DataFetcher df = { env -> currentThread().getName() } - def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null, null) - def returnedValue = modifiedDataFetcher.get(null) - - then: - returnedValue instanceof CompletableFuture - - when: - def value = asCF(returnedValue).join() - - then: - value == "${currentThreadName}" - observer.actions == ["FETCHING on ${currentThreadName}", "PROCESSING on ProcessingThread"] - } - - def "a data fetcher can return a CF and that is handled"() { - when: - instrumentation = build(FetchExecutor, ProcessingExecutor, observer) - - DataFetcher df = { env -> CompletableFuture.completedFuture(currentThread().getName()) } - def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null, null) - def returnedValue = modifiedDataFetcher.get(null) - - then: - returnedValue instanceof CompletableFuture - - when: - def value = asCF(returnedValue).join() - - then: - value == "FetchThread" - observer.actions == ["FETCHING on FetchThread", "PROCESSING on ProcessingThread"] - } - - def "can work in a full schema"() { - def sdl = """ - type Query { - field1 : String - field2 : String - } - """ - DataFetcher df1 = { env -> CompletableFuture.completedFuture("f1" + currentThread().getName()) } - DataFetcher df2 = { env -> "f2" + currentThread().getName() } - - def graphQL = TestUtil.graphQL(sdl, [Query: [field1: df1, field2: df2]]).instrumentation(instrumentation).build() - - when: - def er = graphQL.execute("{field1, field2}") - then: - er.errors.isEmpty() - er.data["field1"] == "f1FetchThread" - er.data["field2"] == "f2FetchThread" - observer.actions.sort() == [ - "FETCHING on FetchThread", "FETCHING on FetchThread", - "PROCESSING on ProcessingThread", "PROCESSING on ProcessingThread" - ] - } -} +//package graphql.execution.instrumentation.threadpools +// +// +//import graphql.TestUtil +//import graphql.schema.DataFetcher +//import graphql.schema.DataFetchingEnvironment +//import graphql.schema.DataFetchingEnvironmentImpl +//import graphql.schema.PropertyDataFetcher +//import spock.lang.Ignore +//import spock.lang.Specification +// +//import java.util.concurrent.CompletableFuture +//import java.util.concurrent.Executor +//import java.util.concurrent.Executors +//import java.util.concurrent.ThreadFactory +//import java.util.function.Consumer +// +//import static ExecutorInstrumentation.Action +//import static java.lang.Thread.currentThread +// +//@Ignore +//class ExecutorInstrumentationTest extends Specification { +// +// private static ThreadFactory threadFactory(String name) { +// new ThreadFactory() { +// @Override +// Thread newThread(Runnable r) { +// return new Thread(r, name) +// } +// } +// } +// +// static class TestingObserver implements Consumer { +// def actions = [] +// +// @Override +// void accept(Action action) { +// actions.add(action.toString() + " on " + currentThread().getName()) +// } +// } +// +// def FetchExecutor = Executors.newSingleThreadExecutor(threadFactory("FetchThread")) +// def ProcessingExecutor = Executors.newSingleThreadExecutor(threadFactory("ProcessingThread")) +// +// ExecutorInstrumentation instrumentation +// def observer = new TestingObserver() +// +// +// ExecutorInstrumentation build(Executor fetchExecutor, Executor processingExecutor, Consumer observer) { +// def builder = ExecutorInstrumentation.newThreadPoolExecutionInstrumentation() +// if (fetchExecutor != null) { +// builder.fetchExecutor(fetchExecutor) +// } +// if (processingExecutor != null) { +// builder.processingExecutor(processingExecutor) +// } +// builder.actionObserver(observer).build() +// } +// +// DataFetchingEnvironment dfEnv(Object s) { +// DataFetchingEnvironmentImpl.newDataFetchingEnvironment().source(s).build() +// } +// +// CompletableFuture asCF(returnedValue) { +// (CompletableFuture) returnedValue +// } +// +// void setup() { +// observer = new TestingObserver() +// instrumentation = build(FetchExecutor, ProcessingExecutor, observer) +// } +// +// def "basic building works"() { +// expect: +// instrumentation.getFetchExecutor() == FetchExecutor +// instrumentation.getProcessingExecutor() == ProcessingExecutor +// } +// +// def "can handle a data fetcher that throws exceptions"() { +// when: +// DataFetcher df = { env -> throw new RuntimeException("BANG") } +// def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null,null) +// def returnedValue = modifiedDataFetcher.get(null) +// +// then: +// returnedValue instanceof CompletableFuture +// +// when: +// asCF(returnedValue).join() +// +// then: +// def e = thrown(RuntimeException) +// e.getMessage().contains("BANG") +// } +// +// +// def "will leave trivial data fetchers as is"() { +// +// when: +// DataFetcher df = PropertyDataFetcher.fetching({ o -> "trivial" }) +// def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null,null) +// def returnedValue = modifiedDataFetcher.get(dfEnv("source")) +// +// then: +// modifiedDataFetcher == df +// returnedValue == "trivial" +// } +// +// +// def "will execute on another thread and transfer execution back to the processing thread"() { +// +// when: +// instrumentation = build(FetchExecutor, ProcessingExecutor, observer) +// +// DataFetcher df = { env -> currentThread().getName() } +// def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null, null) +// def returnedValue = modifiedDataFetcher.get(null) +// +// then: +// returnedValue instanceof CompletableFuture +// +// when: +// def value = asCF(returnedValue).join() +// +// then: +// value == "FetchThread" +// observer.actions == ["FETCHING on FetchThread", "PROCESSING on ProcessingThread"] +// } +// +// @Ignore("This test is flaky on GitHub pipelines") +// def "will execute on another thread and stay there without a processing executor"() { +// +// when: +// instrumentation = build(FetchExecutor, null, observer) +// +// DataFetcher df = { env -> currentThread().getName() } +// def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null, null) +// def returnedValue = modifiedDataFetcher.get(null) +// +// then: +// returnedValue instanceof CompletableFuture +// +// when: +// def value = asCF(returnedValue).join() +// +// then: +// value == "FetchThread" +// observer.actions == ["FETCHING on FetchThread", "PROCESSING on FetchThread"] +// } +// +// def "will fetch on current thread if the executor is null but transfer control back"() { +// +// when: +// def currentThreadName = currentThread().getName() +// instrumentation = build(null, ProcessingExecutor, observer) +// +// DataFetcher df = { env -> currentThread().getName() } +// def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null, null) +// def returnedValue = modifiedDataFetcher.get(null) +// +// then: +// returnedValue instanceof CompletableFuture +// +// when: +// def value = asCF(returnedValue).join() +// +// then: +// value == "${currentThreadName}" +// observer.actions == ["FETCHING on ${currentThreadName}", "PROCESSING on ProcessingThread"] +// } +// +// def "a data fetcher can return a CF and that is handled"() { +// when: +// instrumentation = build(FetchExecutor, ProcessingExecutor, observer) +// +// DataFetcher df = { env -> CompletableFuture.completedFuture(currentThread().getName()) } +// def modifiedDataFetcher = instrumentation.instrumentDataFetcher(df, null, null) +// def returnedValue = modifiedDataFetcher.get(null) +// +// then: +// returnedValue instanceof CompletableFuture +// +// when: +// def value = asCF(returnedValue).join() +// +// then: +// value == "FetchThread" +// observer.actions == ["FETCHING on FetchThread", "PROCESSING on ProcessingThread"] +// } +// +// def "can work in a full schema"() { +// def sdl = """ +// type Query { +// field1 : String +// field2 : String +// } +// """ +// DataFetcher df1 = { env -> CompletableFuture.completedFuture("f1" + currentThread().getName()) } +// DataFetcher df2 = { env -> "f2" + currentThread().getName() } +// +// def graphQL = TestUtil.graphQL(sdl, [Query: [field1: df1, field2: df2]]).instrumentation(instrumentation).build() +// +// when: +// def er = graphQL.execute("{field1, field2}") +// then: +// er.errors.isEmpty() +// er.data["field1"] == "f1FetchThread" +// er.data["field2"] == "f2FetchThread" +// observer.actions.sort() == [ +// "FETCHING on FetchThread", "FETCHING on FetchThread", +// "PROCESSING on ProcessingThread", "PROCESSING on ProcessingThread" +// ] +// } +//} diff --git a/src/test/java/benchmark/AsyncBenchmark.java b/src/test/java/benchmark/AsyncBenchmark.java index a2fa43addd..390486d1f8 100644 --- a/src/test/java/benchmark/AsyncBenchmark.java +++ b/src/test/java/benchmark/AsyncBenchmark.java @@ -52,7 +52,7 @@ private CompletableFuture mkFuture(int i) { @Warmup(iterations = 2, batchSize = 100) @Measurement(iterations = 2, batchSize = 100) public List benchmarkAsync() { - Async.CombinedBuilder builder = Async.ofExpectedSize(futures.size()); + Async.CombinedBuilder builder = Async.ofExpectedSize(futures.size(), null); futures.forEach(builder::add); return builder.await().join(); } From 073d10d9fefc660fb7b6bf2e30c189ad65c6f276 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Sun, 30 Mar 2025 21:09:56 +1000 Subject: [PATCH 19/19] wip --- .../execution/AsyncExecutionStrategy.java | 2 + src/main/java/graphql/execution/CF.java | 45 +++++++++++++++++-- .../PerLevelDataLoaderDispatchStrategy.java | 2 +- .../NoOpPreparsedDocumentProvider.java | 5 +-- 4 files changed, 46 insertions(+), 8 deletions(-) diff --git a/src/main/java/graphql/execution/AsyncExecutionStrategy.java b/src/main/java/graphql/execution/AsyncExecutionStrategy.java index e799f161ec..1d1ab8e035 100644 --- a/src/main/java/graphql/execution/AsyncExecutionStrategy.java +++ b/src/main/java/graphql/execution/AsyncExecutionStrategy.java @@ -38,6 +38,7 @@ public AsyncExecutionStrategy(DataFetcherExceptionHandler exceptionHandler) { @Override @SuppressWarnings("FutureReturnValueIgnored") public CompletableFuture execute(ExecutionContext executionContext, ExecutionStrategyParameters parameters) throws NonNullableFieldWasNullException { + System.out.println("start async execution strategy execute"); DataLoaderDispatchStrategy dataLoaderDispatcherStrategy = executionContext.getDataLoaderDispatcherStrategy(); dataLoaderDispatcherStrategy.executionStrategy(executionContext, parameters); Instrumentation instrumentation = executionContext.getInstrumentation(); @@ -86,6 +87,7 @@ public CompletableFuture execute(ExecutionContext executionCont }); overallResult.whenComplete(executionStrategyCtx::onCompleted); + System.out.println("finished async execution strategy"); return overallResult; } } diff --git a/src/main/java/graphql/execution/CF.java b/src/main/java/graphql/execution/CF.java index da26649dd7..3845a3a53f 100644 --- a/src/main/java/graphql/execution/CF.java +++ b/src/main/java/graphql/execution/CF.java @@ -269,7 +269,29 @@ public class CF extends CompletableFuture { volatile Completion stack; // Top of Treiber stack of dependent actions public final ExecutionContext executionContext; - static final Map EXECUTION_RUNNING = new ConcurrentHashMap<>(); + static final Map EXECUTION_RUNNING = new ConcurrentHashMap<>(); + + static void newCode(ExecutionContext executionContext) { + if (executionContext == null) { + System.out.println("null execution context"); + return; + } + EXECUTION_RUNNING.compute(executionContext, (__, integer) -> { + System.out.println("new code for context: " + executionContext + " count: " + (integer == null ? 1 : integer + 1)); + return integer == null ? 1 : integer + 1; + }); + } + + static void finishedCode(ExecutionContext executionContext) { + if (executionContext == null) { + System.out.println("null execution context"); + return; + } + EXECUTION_RUNNING.compute(executionContext, (__, integer) -> { + System.out.println("finished ode for context: " + executionContext + " count: " + (integer == null ? 0 : integer - 1)); + return integer == null ? 0 : integer - 1; + }); + } final boolean internalComplete(Object r) { // CAS from null to r boolean result = RESULT.compareAndSet(this, null, r); @@ -635,7 +657,6 @@ abstract static class UniCompletion extends Completion { Executor executor; // executor to use (null if none) CF dep; // the dependent to complete CF src; // source for action - public volatile boolean finishedRunningCode; // true if completed UniCompletion(Executor executor, CF dep, CF src) { @@ -742,6 +763,7 @@ final CF tryFire(int mode) { } else { @SuppressWarnings("unchecked") T t = (T) r; d.completeValue(f.apply(t)); + finishedCode(d.executionContext); } } catch (Throwable ex) { d.completeThrowable(ex); @@ -759,6 +781,7 @@ private CF uniApplyStage( if (f == null) { throw new NullPointerException(); } + newCode(executionContext); Object r; if ((r = result) != null) { return uniApplyNow(r, e, f); @@ -785,6 +808,7 @@ private CF uniApplyNow( } else { @SuppressWarnings("unchecked") T t = (T) r; d.assignResult(d.encodeValue(f.apply(t))); + finishedCode(executionContext); } } catch (Throwable ex) { d.assignResult(encodeThrowable(ex)); @@ -827,7 +851,7 @@ final CF tryFire(int mode) { } else { @SuppressWarnings("unchecked") T t = (T) r; f.accept(t); - finishedRunningCode = true; + finishedCode(d.executionContext); d.completeNull(); } } catch (Throwable ex) { @@ -846,6 +870,7 @@ private CF uniAcceptStage(Executor e, if (f == null) { throw new NullPointerException(); } + newCode(executionContext); Object r; if ((r = result) != null) { return uniAcceptNow(r, e, f); @@ -909,6 +934,7 @@ final CF tryFire(int mode) { return null; } else { f.run(); + finishedCode(d.executionContext); d.completeNull(); } } catch (Throwable ex) { @@ -927,6 +953,7 @@ private CF uniRunStage(Executor e, Runnable f) { if (f == null) { throw new NullPointerException(); } + newCode(executionContext); Object r; if ((r = result) != null) { return uniRunNow(r, e, f); @@ -1002,6 +1029,7 @@ final boolean uniWhenComplete(Object r, t = tr; } f.accept(t, x); + finishedCode(executionContext); if (x == null) { internalComplete(r); @@ -1024,6 +1052,7 @@ private CF uniWhenCompleteStage( if (f == null) { throw new NullPointerException(); } + newCode(executionContext); CF d = newIncompleteFuture(executionContext); Object r; if ((r = result) == null) { @@ -1087,6 +1116,7 @@ final boolean uniHandle(Object r, s = ss; } completeValue(f.apply(s, x)); + finishedCode(executionContext); } catch (Throwable ex) { completeThrowable(ex); } @@ -1099,6 +1129,7 @@ private CF uniHandleStage( if (f == null) { throw new NullPointerException(); } + newCode(executionContext); CF d = newIncompleteFuture(executionContext); Object r; if ((r = result) == null) { @@ -1154,6 +1185,7 @@ final boolean uniExceptionally(Object r, } if (r instanceof AltResult && (x = ((AltResult) r).ex) != null) { completeValue(f.apply(x)); + finishedCode(executionContext); } else { internalComplete(r); } @@ -1169,6 +1201,7 @@ private CF uniExceptionallyStage( if (f == null) { throw new NullPointerException(); } + newCode(executionContext); CF d = newIncompleteFuture(executionContext); Object r; if ((r = result) == null) { @@ -1214,6 +1247,7 @@ final CF tryFire(int mode) { return null; } CF g = (CF) f.apply(x).toCompletableFuture(); + finishedCode(d.executionContext); if ((r = g.result) != null) { d.completeRelay(r); } else { @@ -1241,6 +1275,7 @@ private CF uniComposeExceptionallyStage( if (f == null) { throw new NullPointerException(); } + newCode(executionContext); CF d = newIncompleteFuture(executionContext); Object r, s; Throwable x; @@ -1254,6 +1289,7 @@ private CF uniComposeExceptionallyStage( e.execute(new UniComposeExceptionally(null, d, this, f)); } else { CF g = (CF) f.apply(x).toCompletableFuture(); + finishedCode(d.executionContext); if ((s = g.result) != null) { d.assignResult(encodeRelay(s)); } else { @@ -1348,6 +1384,7 @@ final CF tryFire(int mode) { } @SuppressWarnings("unchecked") T t = (T) r; CompletionStage apply = f.apply(t).toCompletableFuture(); + finishedCode(d.executionContext); CF g = (CF) apply; if ((r = g.result) != null) { d.completeRelay(r); @@ -1373,6 +1410,7 @@ private CF uniComposeStage( if (f == null) { throw new NullPointerException(); } + newCode(executionContext); CF d = newIncompleteFuture(executionContext); Object r, s; Throwable x; @@ -1389,6 +1427,7 @@ private CF uniComposeStage( try { @SuppressWarnings("unchecked") T t = (T) r; CF g = (CF) f.apply(t).toCompletableFuture(); + finishedCode(d.executionContext); if ((s = g.result) != null) { d.assignResult(encodeRelay(s)); } else { diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java index d6bb8d18c6..44d1282382 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java @@ -294,7 +294,7 @@ void dispatch(int level) { if (callStack.dataFetchingEnvironmentMap.isEmpty()) { dataLoaderRegistry.dispatchAll(); } else { - CF.dispatch(executionContext, callStack.dataFetchingEnvironmentMap.get(level)); +// CF.dispatch(executionContext, callStack.dataFetchingEnvironmentMap.get(level)); } } diff --git a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java index aa64884c49..20b0983de7 100644 --- a/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java +++ b/src/main/java/graphql/execution/preparsed/NoOpPreparsedDocumentProvider.java @@ -4,8 +4,6 @@ import graphql.ExecutionInput; import graphql.Internal; import graphql.execution.CF; -import graphql.execution.Execution; -import graphql.execution.ExecutionContext; import java.util.concurrent.CompletableFuture; import java.util.function.Function; @@ -16,7 +14,6 @@ public class NoOpPreparsedDocumentProvider implements PreparsedDocumentProvider @Override public CompletableFuture getDocumentAsync(ExecutionInput executionInput, Function parseAndValidateFunction) { - ExecutionContext executionContext = executionInput.getGraphQLContext().get(Execution.EXECUTION_CONTEXT_KEY); - return CF.completedFuture(parseAndValidateFunction.apply(executionInput), executionContext); + return CF.completedFuture(parseAndValidateFunction.apply(executionInput), null); } }