Add way to get/set the default executor.

The default executor is the one that is used by default in the `graphql` and `execute` functions. This commit provides a way to override that executor to one configured to your liking. Additionally, since we are now doing that, the schema must be now passed to the `Executor.execute()` as the first argument, rather than as the first argument to `Executor()`.

Author: jhgg

graphql/core/execution/__init__.py

@@ -28,8 +28,32 @@ def execute(schema, root, ast, operation_name='', args=None):
     """
     Executes an AST synchronously. Assumes that the AST is already validated.
     """
-    e = Executor(schema, [SynchronousExecutionMiddleware()])
-    return e.execute(ast, root, args, operation_name, validate_ast=False)
+    return get_default_executor().execute(schema, ast, root, args, operation_name, validate_ast=False)
 
 
-__all__ = ['ExecutionResult', 'Executor', 'execute']
+_default_executor = None
+
+
+def get_default_executor():
+    """
+        Gets the default executor to be used in the `execute` function above.
+    """
+    global _default_executor
+    if _default_executor is None:
+        _default_executor = Executor([SynchronousExecutionMiddleware()])
+
+    return _default_executor
+
+
+def set_default_executor(executor):
+    """
+        Sets the default executor to be used in the `execute` function above.
+
+        If passed `None` will reset to the original default synchronous executor.
+    """
+    assert isinstance(executor, Executor) or executor is None
+    global _default_executor
+    _default_executor = executor
+
+
+__all__ = ['ExecutionResult', 'Executor', 'execute', 'get_default_executor', 'set_default_executor']

graphql/core/execution/executor.py

@@ -15,16 +15,16 @@
 
 
 class Executor(object):
-    def __init__(self, schema, execution_middlewares=None, default_resolver=default_resolve_fn):
+    def __init__(self, execution_middlewares=None, default_resolver=default_resolve_fn):
         self.execution_middlewares = execution_middlewares or []
         self.default_resolve_fn = default_resolver
-        self.schema = schema
 
-    def execute(self, request='', root=None, args=None, operation_name=None, request_context=None,
+    def execute(self, schema, request='', root=None, args=None, operation_name=None, request_context=None,
                 execute_serially=False, validate_ast=True):
 
         curried_execution_function = functools.partial(
             self._execute,
+            schema,
             request,
             root,
             args,
@@ -40,31 +40,32 @@ def execute(self, request='', root=None, args=None, operation_name=None, request
 
         return curried_execution_function()
 
-    def _execute(self, request, root, args, operation_name, request_context, execute_serially, validate_ast):
+    def _execute(self, schema, request, root, args, operation_name, request_context, execute_serially, validate_ast):
         if not isinstance(request, ast.Document):
             if not isinstance(request, Source):
                 request = Source(request, 'GraphQL request')
 
             request = parse(request)
 
         if validate_ast:
-            validation_errors = validate(self.schema, request)
+            validation_errors = validate(schema, request)
             if validation_errors:
                 return succeed(ExecutionResult(
                     errors=validation_errors,
                     invalid=True,
                 ))
 
         return self._execute_graphql_query(
+            schema,
             root or object(),
             request,
             operation_name,
             args or {},
             request_context or {},
             execute_serially)
 
-    def _execute_graphql_query(self, root, ast, operation_name, args, request_context, execute_serially=False):
-        ctx = ExecutionContext(self.schema, root, ast, operation_name, args, request_context)
+    def _execute_graphql_query(self, schema, root, ast, operation_name, args, request_context, execute_serially=False):
+        ctx = ExecutionContext(schema, root, ast, operation_name, args, request_context)
 
         return defer(self._execute_operation, ctx, root, ctx.operation, execute_serially) \
             .add_errback(

tests/core_execution/test_concurrent_executor.py

@@ -112,14 +112,14 @@ def deeper(self):
     })
 
     schema = GraphQLSchema(query=DataType)
-    executor = Executor(schema)
+    executor = Executor()
 
     def handle_result(result):
         assert not result.errors
         assert result.data == expected
 
-    raise_callback_results(executor.execute(doc, Data(), {'size': 100}, 'Example'), handle_result)
-    raise_callback_results(executor.execute(doc, Data(), {'size': 100}, 'Example', execute_serially=True),
+    raise_callback_results(executor.execute(schema, doc, Data(), {'size': 100}, 'Example'), handle_result)
+    raise_callback_results(executor.execute(schema, doc, Data(), {'size': 100}, 'Example', execute_serially=True),
                            handle_result)
 
 
@@ -142,9 +142,9 @@ def notPromise(self):
     }
     '''
     schema = GraphQLSchema(query=DataType)
-    executor = Executor(schema, [SynchronousExecutionMiddleware()])
+    executor = Executor([SynchronousExecutionMiddleware()])
 
-    result = executor.execute(doc, Data(), operation_name='Example')
+    result = executor.execute(schema, doc, Data(), operation_name='Example')
     assert not isinstance(result, Deferred)
     assert result.data == {"promise": None, 'notPromise': 'i should work'}
     formatted_errors = list(map(format_error, result.errors))
@@ -172,9 +172,9 @@ def notPromise(self):
     }
     '''
     schema = GraphQLSchema(query=DataType)
-    executor = Executor(schema, [SynchronousExecutionMiddleware()])
+    executor = Executor([SynchronousExecutionMiddleware()])
 
-    result = executor.execute(doc, Data(), operation_name='Example')
+    result = executor.execute(schema, doc, Data(), operation_name='Example')
     assert not isinstance(result, Deferred)
     assert result.data is None
     formatted_errors = list(map(format_error, result.errors))
@@ -202,9 +202,9 @@ def notPromise(self):
     }
     '''
     schema = GraphQLSchema(query=DataType)
-    executor = Executor(schema)
+    executor = Executor()
 
-    result = executor.execute(doc, Data(), operation_name='Example')
+    result = executor.execute(schema, doc, Data(), operation_name='Example')
     assert result.called
     result = result.result
     assert result.data is None
@@ -227,9 +227,9 @@ def promise(self):
     }
     '''
     schema = GraphQLSchema(query=DataType)
-    executor = Executor(schema, [SynchronousExecutionMiddleware()])
+    executor = Executor([SynchronousExecutionMiddleware()])
 
-    result = executor.execute(doc, Data(), operation_name='Example')
+    result = executor.execute(schema, doc, Data(), operation_name='Example')
     assert not isinstance(result, Deferred)
     assert result.data == {"promise": 'I should work'}
     assert not result.errors

tests/core_execution/test_default_executor.py

@@ -0,0 +1,16 @@
+from graphql.core.execution import get_default_executor, set_default_executor, Executor
+
+
+def test_get_and_set_default_executor():
+    e1 = get_default_executor()
+    e2 = get_default_executor()
+    assert e1 is e2
+
+    new_executor = Executor()
+
+    set_default_executor(new_executor)
+    assert get_default_executor() is new_executor
+
+    set_default_executor(None)
+    assert get_default_executor() is not e1
+    assert get_default_executor() is not new_executor

tests/core_execution/test_gevent.py

@@ -31,8 +31,8 @@ def resolver_2(context, *_):
         'b': GraphQLField(GraphQLString, resolver=resolver_2)
     })
 
-    executor = Executor(GraphQLSchema(Type), [GeventExecutionMiddleware()])
-    result = executor.execute(doc)
+    executor = Executor([GeventExecutionMiddleware()])
+    result = executor.execute(GraphQLSchema(Type), doc)
     assert not result.errors
     assert result.data == {'a': 'hey', 'b': 'hey2'}
 
@@ -55,8 +55,8 @@ def resolver_2(context, *_):
         'b': GraphQLField(GraphQLString, resolver=resolver_2)
     })
 
-    executor = Executor(GraphQLSchema(Type), [GeventExecutionMiddleware()])
-    result = executor.execute(doc)
+    executor = Executor([GeventExecutionMiddleware()])
+    result = executor.execute(GraphQLSchema(Type), doc)
     formatted_errors = list(map(format_error, result.errors))
     assert formatted_errors == [{'locations': [{'line': 1, 'column': 20}], 'message': 'resolver_2 failed!'}]
     assert result.data == {'a': 'hey', 'b': None}

tests/core_execution/utils.py

@@ -1,32 +1,32 @@
-from graphql.core.pyutils.defer import Deferred, DeferredException
+from graphql.core.pyutils.defer import Deferred, DeferredException, _passthrough
 
 
 class RaisingDeferred(Deferred):
     def _next(self):
         """Process the next callback."""
         if self._running or self.paused:
             return
+
         while self.callbacks:
             # Get the next callback pair
             next_pair = self.callbacks.pop(0)
             # Continue with the errback if the last result was an exception
             callback, args, kwargs = next_pair[isinstance(self.result,
                                                           DeferredException)]
-            try:
-                self.result = callback(self.result, *args, **kwargs)
-            except:
-                self.result = DeferredException()
-            finally:
-                self._running = False
-
-            if isinstance(self.result, Deferred):
-                # If a Deferred was returned add this deferred as callbacks to
-                # the returned one. As a result the processing of this Deferred
-                # will be paused until all callbacks of the returned Deferred
-                # have been performed
-                self.result.add_callbacks(self._continue, self._continue)
-                self.paused == True
-                break
+
+            if callback is not _passthrough:
+                self._running = True
+                try:
+                    self.result = callback(self.result, *args, **kwargs)
+
+                except:
+                    self.result = DeferredException()
+
+                finally:
+                    self._running = False
+
+                if isinstance(self.result, Exception):
+                    self.result = DeferredException(self.result)
 
         if isinstance(self.result, DeferredException):
             # Print the exception to stderr and stop if there aren't any
@@ -39,5 +39,3 @@ def raise_callback_results(deferred, callback):
     d.add_callback(lambda r: r)
     d.callback(deferred)
     d.add_callback(callback)
-
-

tests_py35/core_execution/test_asyncio_executor.py

@@ -38,8 +38,8 @@ async def resolver_2(context, *_):
         'b': GraphQLField(GraphQLString, resolver=resolver_2)
     })
 
-    executor = Executor(GraphQLSchema(Type), [AsyncioExecutionMiddleware()])
-    result = await executor.execute(doc)
+    executor = Executor([AsyncioExecutionMiddleware()])
+    result = await executor.execute(GraphQLSchema(Type), doc)
     assert not result.errors
     assert result.data == {'a': 'hey', 'b': 'hey2'}
 
@@ -60,8 +60,8 @@ async def resolver_2(context, *_):
         'b': GraphQLField(GraphQLString, resolver=resolver_2)
     })
 
-    executor = Executor(GraphQLSchema(Type), [AsyncioExecutionMiddleware()])
-    result = await executor.execute(doc)
+    executor = Executor([AsyncioExecutionMiddleware()])
+    result = await executor.execute(GraphQLSchema(Type), doc)
     formatted_errors = list(map(format_error, result.errors))
     assert formatted_errors == [{'locations': [{'line': 1, 'column': 20}], 'message': 'resolver_2 failed!'}]
     assert result.data == {'a': 'hey', 'b': None}