Implement gevent middleware.

Author: jhgg

.travis.yml

@@ -7,7 +7,7 @@ python:
 - 3.5
 - pypy
 install:
-- pip install pytest-cov coveralls flake8 import-order
+- pip install pytest-cov coveralls flake8 import-order gevent>=1.1b5
 - pip install pytest>=2.7.3 --upgrade
 - pip install -e .
 script:

graphql/core/execution/executor.py

@@ -287,7 +287,7 @@ def run_resolve_fn(self, resolve_fn, source, args, info):
         try:
             for middleware in self.execution_middlewares:
                 if hasattr(middleware, 'run_resolve_fn'):
-                    curried_resolve_fn = functools.partial(middleware.run_resolve_fn, curried_resolve_fn)
+                    curried_resolve_fn = functools.partial(middleware.run_resolve_fn, curried_resolve_fn, resolve_fn)
 
             return curried_resolve_fn()
         except Exception as e:

graphql/core/execution/middlewares/asyncio.py

@@ -16,7 +16,7 @@ def handle_future_result(future):
 
 
 class AsyncioExecutionMiddleware(object):
-    def run_resolve_fn(self, resolver):
+    def run_resolve_fn(self, resolver, original_resolver):
         result = resolver()
         if isinstance(result, Future) or iscoroutine(result):
             future = ensure_future(result)
@@ -32,7 +32,5 @@ def execution_result(self, executor):
         assert isinstance(result, Deferred), 'Another middleware has converted the execution result ' \
                                              'away from a Deferred.'
 
-        result.add_callback(future.set_result)
-        result.add_errback(future.set_exception)
-
+        result.add_callbacks(future.set_result, future.set_exception)
         return future

graphql/core/execution/middlewares/gevent.py

@@ -0,0 +1,47 @@
+from __future__ import absolute_import
+
+from gevent import get_hub, spawn
+from gevent.event import AsyncResult
+from graphql.core.defer import Deferred, DeferredException
+
+
+def _run_resolver_in_greenlet(d, resolver):
+    try:
+        result = resolver()
+        get_hub().loop.run_callback(d.callback, result)
+    except:
+        e = DeferredException()
+        get_hub().loop.run_callback(d.errback, e)
+
+
+def run_in_greenlet(f):
+    """
+        Marks a resolver to run inside a greenlet.
+
+        @run_in_greenlet
+        def resolve_something(context, _*):
+            gevent.sleep(1)
+            return 5
+
+    """
+    f._run_in_greenlet = True
+    return f
+
+
+class GeventExecutionMiddleware(object):
+    def run_resolve_fn(self, resolver, original_resolver):
+        if hasattr(original_resolver, '_run_in_greenlet'):
+            d = Deferred()
+            spawn(_run_resolver_in_greenlet, d, resolver)
+            return d
+
+        return resolver()
+
+    def execution_result(self, executor):
+        result = AsyncResult()
+        deferred = executor()
+        assert isinstance(deferred, Deferred), 'Another middleware has converted the execution result ' \
+                                               'away from a Deferred.'
+
+        deferred.add_callbacks(result.set, lambda e: result.set_exception(e.value, (e.type, e.value, e.traceback)))
+        return result.get()

graphql/core/execution/middlewares/sync.py

@@ -3,7 +3,7 @@
 
 
 class SynchronousExecutionMiddleware(object):
-    def run_resolve_fn(self, resolver):
+    def run_resolve_fn(self, resolver, original_resolver):
         result = resolver()
         if isinstance(result, Deferred):
             raise GraphQLError('You cannot return a Deferred from a resolver when using SynchronousExecutionMiddleware')

tests/core_execution/test_gevent.py

@@ -0,0 +1,61 @@
+# flake8: noqa
+
+from graphql.core.execution import Executor
+from graphql.core.execution.middlewares.gevent import GeventExecutionMiddleware, run_in_greenlet
+from graphql.core.language.location import SourceLocation
+from graphql.core.type import (
+    GraphQLSchema,
+    GraphQLObjectType,
+    GraphQLField,
+    GraphQLString
+)
+
+import gevent
+
+
+def test_gevent_executor():
+    doc = 'query Example { a, b }'
+
+    @run_in_greenlet
+    def resolver(context, *_):
+        gevent.sleep(0.001)
+        return 'hey'
+
+    @run_in_greenlet
+    def resolver_2(context, *_):
+        gevent.sleep(0.003)
+        return 'hey2'
+
+    Type = GraphQLObjectType('Type', {
+        'a': GraphQLField(GraphQLString, resolver=resolver),
+        'b': GraphQLField(GraphQLString, resolver=resolver_2)
+    })
+
+    executor = Executor(GraphQLSchema(Type), [GeventExecutionMiddleware()])
+    result = executor.execute(doc)
+    assert not result.errors
+    assert result.data == {'a': 'hey', 'b': 'hey2'}
+
+
+def test_gevent_executor_with_error():
+    doc = 'query Example { a, b }'
+
+    @run_in_greenlet
+    def resolver(context, *_):
+        gevent.sleep(0.001)
+        return 'hey'
+
+    @run_in_greenlet
+    def resolver_2(context, *_):
+        gevent.sleep(0.003)
+        raise Exception('resolver_2 failed!')
+
+    Type = GraphQLObjectType('Type', {
+        'a': GraphQLField(GraphQLString, resolver=resolver),
+        'b': GraphQLField(GraphQLString, resolver=resolver_2)
+    })
+
+    executor = Executor(GraphQLSchema(Type), [GeventExecutionMiddleware()])
+    result = executor.execute(doc)
+    assert result.errors == [{'locations': [SourceLocation(1, 20)], 'message': 'resolver_2 failed!'}]
+    assert result.data == {'a': 'hey', 'b': None}

tox.ini

@@ -4,8 +4,9 @@ envlist = flake8,import-order,py27,py33,py34,py35,pypy,docs
 [testenv]
 deps =
     pytest>=2.7.2
+    gevent==1.1b5
 commands =
-    py{27,33,34}: py.test tests
+    py{27,33,34,py}: py.test tests
     py35: py.test tests tests_py35
 
 
@@ -15,7 +16,9 @@ commands = flake8
 
 [testenv:import-order]
 basepython=python3.5
-deps = import-order
+deps =
+    import-order
+    gevent==1.1b5
 commands = import-order graphql
 
 [testenv:docs]