Fix executor & add resolver tagging.

Author: jhgg

graphql/core/execution/executor.py

@@ -20,24 +20,27 @@ def __init__(self, schema, execution_middlewares=None, default_resolver=default_
         self.default_resolve_fn = default_resolver
         self.schema = schema
 
-    def execute(self, request='', root=None, args=None, operation_name=None, execute_serially=False, validate_ast=True):
+    def execute(self, request='', root=None, args=None, operation_name=None, request_context=None,
+                execute_serially=False, validate_ast=True):
+
         curried_execution_function = functools.partial(
             self._execute,
             request,
             root,
             args,
             operation_name,
+            request_context,
             execute_serially,
-            validate_ast)
+            validate_ast
+        )
 
         for middleware in self.execution_middlewares:
             if hasattr(middleware, 'execution_result'):
                 curried_execution_function = functools.partial(middleware.execution_result, curried_execution_function)
 
         return curried_execution_function()
 
-    def _execute(self, request='', root=None, args=None, operation_name=None, request_context=None,
-                 execute_serially=False, validate_ast=True):
+    def _execute(self, 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')

graphql/core/execution/middlewares/gevent.py

@@ -2,7 +2,8 @@
 
 from gevent import get_hub, spawn
 from gevent.event import AsyncResult
-from graphql.core.defer import Deferred, DeferredException
+from ...defer import Deferred, DeferredException
+from .utils import resolver_has_tag, tag_resolver
 
 
 def _run_resolver_in_greenlet(d, resolver):
@@ -24,13 +25,12 @@ def resolve_something(context, _*):
             return 5
 
     """
-    f._run_in_greenlet = True
-    return f
+    return tag_resolver(f, 'run_in_greenlet')
 
 
 class GeventExecutionMiddleware(object):
     def run_resolve_fn(self, resolver, original_resolver):
-        if hasattr(original_resolver, '_run_in_greenlet'):
+        if resolver_has_tag(original_resolver, 'run_in_greenlet'):
             d = Deferred()
             spawn(_run_resolver_in_greenlet, d, resolver)
             return d

graphql/core/execution/middlewares/utils.py

@@ -0,0 +1,33 @@
+def tag_resolver(f, tag):
+    """
+    Tags a resolver function with a specific tag that can be read by a Middleware to denote specific functionality.
+    :param f: The function to tag.
+    :param tag: The tag to add to the function.
+    :return: The function with the tag added.
+    """
+    if not hasattr(f, '_resolver_tags'):
+        f._resolver_tags = set()
+
+    f._resolver_tags.add(tag)
+    return f
+
+
+def resolver_has_tag(f, tag):
+    """
+        Checks to see if a function has a specific tag.
+    """
+    if not hasattr(f, '_resolver_tags'):
+        return False
+
+    return tag in f._resolver_tags
+
+
+def merge_resolver_resolver_tags(source_resolver, target_resolver):
+    if not hasattr(source_resolver, '_resolver_tags'):
+        return target_resolver
+
+    if not hasattr(target_resolver, '_resolver_tags'):
+        target_resolver._resolver_tags = set()
+
+    target_resolver._resolver_tags |= source_resolver._resolver_tags
+    return target_resolver