Use thread pool executor for async queries

Author: jnutting512

src/main/java/graphql/servlet/AbstractGraphQLHttpServlet.java

@@ -51,7 +51,7 @@ public abstract class AbstractGraphQLHttpServlet extends HttpServlet implements
     private static final String[] MULTIPART_KEYS = new String[]{"operations", "graphql", "query"};
 
     private GraphQLConfiguration configuration;
-
+    
     /**
      * @deprecated override {@link #getConfiguration()} instead
      */
@@ -292,7 +292,7 @@ private void doRequestAsync(HttpServletRequest request, HttpServletResponse resp
             AsyncContext asyncContext = request.startAsync();
             HttpServletRequest asyncRequest = (HttpServletRequest) asyncContext.getRequest();
             HttpServletResponse asyncResponse = (HttpServletResponse) asyncContext.getResponse();
-            new Thread(() -> doRequest(asyncRequest, asyncResponse, handler, asyncContext)).start();
+            configuration.getAsyncExecutor().execute(() -> doRequest(asyncRequest, asyncResponse, handler, asyncContext));
         } else {
             doRequest(request, response, handler, null);
         }

src/main/java/graphql/servlet/GraphQLConfiguration.java

@@ -1,10 +1,12 @@
 package graphql.servlet;
 
 import graphql.schema.GraphQLSchema;
+import graphql.servlet.internal.GraphQLThreadFactory;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
 
 public class GraphQLConfiguration {
 
@@ -13,6 +15,7 @@ public class GraphQLConfiguration {
     private GraphQLObjectMapper objectMapper;
     private List<GraphQLServletListener> listeners;
     private boolean asyncServletModeEnabled;
+    private Executor asyncExecutor;
 
     public static GraphQLConfiguration.Builder with(GraphQLSchema schema) {
         return with(new DefaultGraphQLSchemaProvider(schema));
@@ -26,12 +29,13 @@ public static GraphQLConfiguration.Builder with(GraphQLInvocationInputFactory in
         return new Builder(invocationInputFactory);
     }
 
-    private GraphQLConfiguration(GraphQLInvocationInputFactory invocationInputFactory, GraphQLQueryInvoker queryInvoker, GraphQLObjectMapper objectMapper, List<GraphQLServletListener> listeners, boolean asyncServletModeEnabled) {
+    private GraphQLConfiguration(GraphQLInvocationInputFactory invocationInputFactory, GraphQLQueryInvoker queryInvoker, GraphQLObjectMapper objectMapper, List<GraphQLServletListener> listeners, boolean asyncServletModeEnabled, Executor asyncExecutor) {
         this.invocationInputFactory = invocationInputFactory;
         this.queryInvoker = queryInvoker;
         this.objectMapper = objectMapper;
         this.listeners = listeners;
         this.asyncServletModeEnabled = asyncServletModeEnabled;
+        this.asyncExecutor = asyncExecutor;
     }
 
     public GraphQLInvocationInputFactory getInvocationInputFactory() {
@@ -54,6 +58,10 @@ public boolean isAsyncServletModeEnabled() {
         return asyncServletModeEnabled;
     }
 
+    public Executor getAsyncExecutor() {
+        return asyncExecutor;
+    }
+
     public void add(GraphQLServletListener listener) {
         listeners.add(listener);
     }
@@ -70,6 +78,7 @@ public static class Builder {
         private GraphQLObjectMapper objectMapper = GraphQLObjectMapper.newBuilder().build();
         private List<GraphQLServletListener> listeners = new ArrayList<>();
         private boolean asyncServletModeEnabled = false;
+        private Executor asyncExecutor = Executors.newCachedThreadPool(new GraphQLThreadFactory());
 
         private Builder(GraphQLInvocationInputFactory.Builder invocationInputFactoryBuilder) {
             this.invocationInputFactoryBuilder = invocationInputFactoryBuilder;
@@ -105,6 +114,13 @@ public Builder with(boolean asyncServletModeEnabled) {
             return this;
         }
 
+        public Builder with(Executor asyncExecutor) {
+            if (asyncExecutor != null) {
+            	this.asyncExecutor = asyncExecutor;
+            }
+            return this;
+        }
+
         public Builder with(GraphQLContextBuilder contextBuilder) {
             this.invocationInputFactoryBuilder.withGraphQLContextBuilder(contextBuilder);
             return this;
@@ -121,7 +137,8 @@ public GraphQLConfiguration build() {
                     queryInvoker,
                     objectMapper,
                     listeners,
-                    asyncServletModeEnabled
+                    asyncServletModeEnabled,
+                    asyncExecutor
             );
         }
 

src/main/java/graphql/servlet/internal/GraphQLThreadFactory.java

@@ -0,0 +1,26 @@
+package graphql.servlet.internal;
+
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import graphql.servlet.AbstractGraphQLHttpServlet;
+
+/**
+ * {@link ThreadFactory} implementation for {@link AbstractGraphQLHttpServlet} async operations
+ * 
+ * @author John Nutting
+ */
+public class GraphQLThreadFactory implements ThreadFactory {
+
+	final static String NAME_PREFIX = "GraphQLServlet-";
+	final AtomicInteger threadNumber = new AtomicInteger(1);
+
+	@Override
+	public Thread newThread(final Runnable r) {
+		Thread t = new Thread(r, NAME_PREFIX + threadNumber.getAndIncrement());
+		t.setDaemon(false);
+		t.setPriority(Thread.NORM_PRIORITY);
+		return t;
+	}
+
+}

src/test/groovy/graphql/servlet/AbstractGraphQLHttpServletSpec.groovy

@@ -7,6 +7,7 @@ import graphql.execution.ExecutionStepInfo
 import graphql.execution.instrumentation.ChainedInstrumentation
 
 import graphql.execution.instrumentation.Instrumentation
+import graphql.schema.DataFetcher
 import graphql.schema.GraphQLNonNull
 import org.dataloader.DataLoaderRegistry
 import org.springframework.mock.web.MockHttpServletRequest
@@ -38,6 +39,7 @@ class AbstractGraphQLHttpServletSpec extends Specification {
     def setup() {
         servlet = TestUtils.createServlet()
         request = new MockHttpServletRequest()
+        request.setAsyncSupported(true)
         response = new MockHttpServletResponse()
     }
 
@@ -84,6 +86,18 @@ class AbstractGraphQLHttpServletSpec extends Specification {
         getResponseContent().data.echo == "test"
     }
 
+    def "async query over HTTP GET starts async request"() {
+        setup:
+        servlet = TestUtils.createServlet({ env -> env.arguments.arg },{ env -> env.arguments.arg }, true)
+        request.addParameter('query', 'query { echo(arg:"test") }')
+
+        when:
+        servlet.doGet(request, response)
+
+        then:
+        request.asyncStarted == true
+    }
+
     def "query over HTTP GET with variables returns data"() {
         setup:
         request.addParameter('query', 'query Echo($arg: String) { echo(arg:$arg) }')
@@ -286,6 +300,20 @@ class AbstractGraphQLHttpServletSpec extends Specification {
         getResponseContent().data.echo == "test"
     }
 
+    def "async query over HTTP POST starts async request"() {
+        setup:
+        servlet = TestUtils.createServlet({ env -> env.arguments.arg },{ env -> env.arguments.arg }, true)
+		request.setContent(mapper.writeValueAsBytes([
+				query: 'query { echo(arg:"test") }'
+		]))
+
+        when:
+        servlet.doPost(request, response)
+
+        then:
+        request.asyncStarted == true
+    }
+
     def "query over HTTP POST body with graphql contentType returns data"() {
         setup:
         request.addHeader("Content-Type", "application/graphql")

src/test/groovy/graphql/servlet/TestUtils.groovy

@@ -8,10 +8,13 @@ import graphql.schema.*
 class TestUtils {
 
     static def createServlet(DataFetcher queryDataFetcher = { env -> env.arguments.arg },
-                             DataFetcher mutationDataFetcher = { env -> env.arguments.arg }) {
+                             DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
+                             boolean asyncServletModeEnabled = false) {
         GraphQLHttpServlet servlet = GraphQLHttpServlet.with(GraphQLConfiguration
                 .with(createGraphQlSchema(queryDataFetcher, mutationDataFetcher))
-                .with(createInstrumentedQueryInvoker()).build())
+                .with(createInstrumentedQueryInvoker())
+                .with(asyncServletModeEnabled)
+                .build())
         servlet.init(null)
         return servlet
     }