Upgrade to RxJava 1.2.7 / Refine observable handling

graemerocher · graemerocher · commit c3616d123534 · 2017-03-01T16:29:43.000+01:00
diff --git a/build.gradle b/build.gradle
@@ -50,7 +50,7 @@ dependencies {
     compile "org.springframework.boot:spring-boot-starter-tomcat"
     compile "org.grails:grails-dependencies"
     compile "org.grails:grails-web-boot"
-    compile 'io.reactivex:rxjava:1.2.6'
+    compile 'io.reactivex:rxjava:1.2.7'
 
     console "org.grails:grails-console"
 
diff --git a/src/docs/asciidoc/gettingStarted.adoc b/src/docs/asciidoc/gettingStarted.adoc
@@ -16,7 +16,7 @@ You then may want to include an implementation of RxGORM, for the examples in th
 ----
 dependencies {
     ...
-    compile 'org.grails.plugins:rx-mongodb:6.0.0.M2'
+    compile 'org.grails.plugins:rx-mongodb:6.0.7'
 }
 ----
 
diff --git a/src/docs/asciidoc/serverSentEvents.adoc b/src/docs/asciidoc/serverSentEvents.adoc
@@ -8,15 +8,15 @@ For example:
 ----
 def index() {
 
-    rx.stream { Subscriber subscriber -> <1>
+    rx.stream { rx.Observer observer -> <1>
        for(i in (0..5)) {
            if(i % 2 == 0) {
-               subscriber.onNext(
+               observer.onNext(
                    rx.render("Tick") <2>
                )
            }
            else {
-               subscriber.onNext(
+               observer.onNext(
                    rx.render("Tock")
                )
 
@@ -28,7 +28,7 @@ def index() {
 }
 ----
 
-<1> Call the `stream` method passing a closure that accepts an `rx.Subscriber` to start sending events
+<1> Call the `stream` method passing a closure that accepts an `rx.Observer` to start sending events
 <2> Emit a one or many items using `onNext`
 <3> Call `sleep` to simulate a slow request
 <4> Call `onCompleted` to complete the request
@@ -60,7 +60,7 @@ If you wish to send a particular named event you can use the name argument of th
 
 [source,groovy]
 ----
-stream "ticktock", { Subscriber subscriber ->
+stream "ticktock", { rx.Observer observer ->
 ----
 
 And then attach an event listener for only that event on the client:
@@ -80,10 +80,10 @@ In addition for more complex event types you can use the `rx.event` method:
 
 [source,groovy]
 ----
-    rx.stream { Subscriber subscriber ->
+    rx.stream { rx.Observer observer ->
        for(i in (0..5)) {
            if(i % 2 == 0) {
-               subscriber.onNext(
+               observer.onNext(
                    rx.event("Tick", event:"Event $i", id:"$id", comment:"Tick Event") <1>
                )
            }
diff --git a/src/main/groovy/grails/rx/web/Rx.groovy b/src/main/groovy/grails/rx/web/Rx.groovy
@@ -1,6 +1,5 @@
 package grails.rx.web
 
-import grails.async.Promises
 import grails.web.databinding.DataBindingUtils
 import grails.web.mapping.mvc.exceptions.CannotRedirectException
 import groovy.transform.CompileDynamic
@@ -17,10 +16,11 @@ import org.grails.web.servlet.mvc.GrailsWebRequest
 import org.springframework.web.context.request.RequestContextHolder
 import org.springframework.web.context.request.async.WebAsyncManager
 import org.springframework.web.context.request.async.WebAsyncUtils
+import rx.Emitter
 import rx.Observable
 import rx.Subscriber
+import rx.functions.Action1
 
-import javax.servlet.ServletInputStream
 import javax.servlet.http.HttpServletRequest
 import java.util.concurrent.TimeUnit
 
@@ -223,36 +223,36 @@ class Rx {
      */
     @CompileDynamic
     static Observable bindData(Object object, Object bindingSource, Map arguments = Collections.emptyMap(), String filter = null) {
-        Observable.create( { Subscriber<? super Object> subscriber ->
-                subscriber.onStart()
-                Promises.task {
-                    if(bindingSource instanceof HttpServletRequest) {
-                        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(bindingSource)
-                        // horrible hack, find better solution
-                        GrailsWebRequest webRequest = asyncManager != null ? asyncManager.@asyncWebRequest : null
-                        if(webRequest != null) {
-                            RequestContextHolder.setRequestAttributes(webRequest)
-                            try {
-                                List includeList = convertToListIfCharSequence(arguments?.include)
-                                List excludeList = convertToListIfCharSequence(arguments?.exclude)
-
-                                DataBindingUtils.bindObjectToInstance(object, bindingSource, includeList, excludeList, filter)
-                            } finally {
-                                RequestContextHolder.setRequestAttributes(null)
-                            }
-                        }
-                        else {
-                            object.properties = bindingSource
+        Observable.create( { Emitter<? super Object> emitter ->
+            try {
+                if(bindingSource instanceof HttpServletRequest) {
+                    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(bindingSource)
+                    // horrible hack, find better solution
+                    GrailsWebRequest webRequest = asyncManager != null ? asyncManager.@asyncWebRequest : null
+                    if(webRequest != null) {
+                        RequestContextHolder.setRequestAttributes(webRequest)
+                        try {
+                            List includeList = convertToListIfCharSequence(arguments?.include)
+                            List excludeList = convertToListIfCharSequence(arguments?.exclude)
+
+                            DataBindingUtils.bindObjectToInstance(object, bindingSource, includeList, excludeList, filter)
+                        } finally {
+                            RequestContextHolder.setRequestAttributes(null)
                         }
                     }
                     else {
                         object.properties = bindingSource
                     }
-                    subscriber.onNext(object)
-                    subscriber.onCompleted()
-
                 }
-        } as Observable.OnSubscribe<Object>)
+                else {
+                    object.properties = bindingSource
+                }
+                emitter.onNext(object)
+                emitter.onCompleted()
+            } catch (Throwable e) {
+                emitter.onError(e)
+            }
+        } as Action1<Emitter<InputStream>>, Emitter.BackpressureMode.NONE)
     }
 
 
@@ -264,24 +264,28 @@ class Rx {
      * @return An observable
      */
     static Observable<InputStream> fromBody(HttpServletRequest request) {
-        Observable.create( { Subscriber<InputStream> subscriber ->
-            subscriber.onStart()
-            Promises.task {
-                InputStream inputStream = null
+        Observable.create( { Emitter<InputStream> subscriber ->
+            WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request)
+            if(!asyncManager.isConcurrentHandlingStarted()) {
+                throw new IllegalStateException("Servlet async processing must have been started to use fromBody(..)")
+            }
+            InputStream inputStream = null
+            try {
                 try {
-                    try {
-                        inputStream = request.getInputStream()
-                        subscriber.onNext(inputStream)
-                    } catch (Throwable e) {
-                        subscriber.onError(e)
-                    }
-                } finally {
+                    inputStream = request.getInputStream()
+                    subscriber.onNext(inputStream)
                     subscriber.onCompleted()
+                } catch (Throwable e) {
+                    subscriber.onError(e)
+                }
+            } finally {
+                try {
                     inputStream?.close()
+                } catch (Throwable e) {
+                    // ignore
                 }
-
             }
-        } as Observable.OnSubscribe<InputStream>)
+        } as Action1<Emitter<InputStream>>, Emitter.BackpressureMode.NONE)
     }
 
     /**
diff --git a/src/main/groovy/org/grails/plugins/rx/web/NewObservableResult.groovy b/src/main/groovy/org/grails/plugins/rx/web/NewObservableResult.groovy
@@ -1,8 +1,7 @@
 package org.grails.plugins.rx.web
 
 import groovy.transform.CompileStatic
-import rx.Observable
-import rx.Subscriber
+import rx.Observer
 
 import java.util.concurrent.TimeUnit
 
@@ -21,9 +20,9 @@ class NewObservableResult<T> extends TimeoutResult {
         super(timeout, unit)
         this.callable = callable
         def parameterTypes = this.callable.parameterTypes
-        boolean isSubscriber = parameterTypes.length == 1 && Subscriber.isAssignableFrom(parameterTypes[0])
+        boolean isSubscriber = parameterTypes.length == 1 && Observer.isAssignableFrom(parameterTypes[0])
         if(!isSubscriber) {
-            throw new IllegalArgumentException("Passed closure must accept argument of type rx.Subscriber")
+            throw new IllegalArgumentException("Passed closure must accept argument of type rx.Observer")
         }
     }
 
diff --git a/src/main/groovy/org/grails/plugins/rx/web/RxResultTransformer.groovy b/src/main/groovy/org/grails/plugins/rx/web/RxResultTransformer.groovy
@@ -15,8 +15,11 @@ import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.web.context.request.async.AsyncWebRequest
 import org.springframework.web.context.request.async.WebAsyncManager
 import org.springframework.web.context.request.async.WebAsyncUtils
+import rx.Emitter
 import rx.Observable
 import rx.Subscriber
+import rx.functions.Action1
+import rx.schedulers.Schedulers
 
 import javax.servlet.AsyncContext
 import javax.servlet.ServletResponse
@@ -117,18 +120,22 @@ class RxResultTransformer implements ActionResultTransformer {
 
                 // in a separate thread register the observable subscriber
                 asyncContext.start {
-                    observable.subscribe(subscriber)
+                    observable.observeOn(Schedulers.immediate()) // run on the async servlet thread
+                              .subscribe(subscriber)
                 }
             }
             else {
                 asyncContext.start {
                     NewObservableResult newObservableResult = (NewObservableResult)actionResult
-                    Observable newObservable = Observable.create( { Subscriber newSub ->
+
+                    Observable newObservable = Observable.create( { Emitter newSub ->
                         Closure callable = newObservableResult.callable
                         callable.setDelegate(newSub)
                         callable.call(newSub)
-                    } as Observable.OnSubscribe)
-                    newObservable.subscribe(subscriber)
+                    } as Action1<Emitter>, Emitter.BackpressureMode.NONE)
+                    newObservable
+                        .observeOn(Schedulers.immediate()) // run on the async servlet thread
+                        .subscribe(subscriber)
                 }
             }
             // return null indicating that the request thread should be returned to the thread pool
diff --git a/src/test/groovy/org/grails/plugins/rx/EventSpec.groovy b/src/test/groovy/org/grails/plugins/rx/EventSpec.groovy
@@ -13,6 +13,8 @@ import org.grails.web.servlet.mvc.GrailsWebRequest
 import org.grails.web.util.GrailsApplicationAttributes
 import org.springframework.mock.web.MockHttpServletRequest
 import org.springframework.web.context.request.RequestContextHolder
+import rx.Emitter
+import rx.Observer
 import rx.Subscriber
 import spock.lang.Specification
 
@@ -126,23 +128,23 @@ class EventController implements Controller, RestResponder{
     RxHelper rx = new RxHelper()
 
     def stream() {
-        rx.stream { Subscriber subscriber ->
+        rx.stream { Observer observer ->
             for(i in 0..3) {
-                subscriber.onNext(
+                observer.onNext(
                         rx.event("Foo $i\nFoo\nBar\nBaz", event: "Event $i", comment: 'potato', id: "$i")
                 )
             }
-            subscriber.onCompleted()
+            observer.onCompleted()
         }
     }
 
     def streamJson() {
-        rx.stream { Subscriber subscriber ->
+        rx.stream { Emitter emitter ->
             for(i in 0..3) {
                 def foo =  """bar $i
 bar $i"""
                 def json = [foo: foo, 'baz': 3] as JSON
-                subscriber.onNext(
+                emitter.onNext(
                         rx.event(new Writable() {
                             @Override
                             Writer writeTo(Writer writer) throws IOException {
@@ -151,7 +153,7 @@ bar $i"""
                         }, id: "$i", retry: 1000)
                 )
             }
-            subscriber.onCompleted()
+            emitter.onCompleted()
         }
     }
 }
diff --git a/src/test/groovy/org/grails/plugins/rx/NewObservableResultSpec.groovy b/src/test/groovy/org/grails/plugins/rx/NewObservableResultSpec.groovy
@@ -14,6 +14,7 @@ import org.grails.web.servlet.mvc.GrailsWebRequest
 import org.grails.web.util.GrailsApplicationAttributes
 import org.springframework.mock.web.MockHttpServletRequest
 import org.springframework.web.context.request.RequestContextHolder
+import rx.Emitter
 import rx.Subscriber
 import spock.lang.Specification
 import static grails.rx.web.Rx.*
@@ -119,35 +120,35 @@ data: {"foo":"bar 3"}
 }
 class NewObservableController implements Controller, RestResponder{
     def index() {
-        create { Subscriber subscriber ->
-            subscriber.onNext(
+        create { Emitter emitter ->
+            emitter.onNext(
                 render("Foo")
             )
-            subscriber.onCompleted()
+            emitter.onCompleted()
         }
     }
 
     def stream() {
-        stream { Subscriber subscriber ->
+        stream { Emitter emittter ->
             for(i in 0..3) {
-                subscriber.onNext(
+                emittter.onNext(
                         render("Foo $i")
                 )
             }
-            subscriber.onCompleted()
+            emittter.onCompleted()
         }
     }
 
     def streamJson() {
-        stream { Subscriber subscriber ->
+        stream { Emitter emitter ->
             for(i in 0..3) {
-                subscriber.onNext(
+                emitter.onNext(
                         render(contentType:"application/json") {
                             foo "bar $i"
                         }
                 )
             }
-            subscriber.onCompleted()
+            emitter.onCompleted()
         }
     }
 }
diff --git a/src/test/groovy/org/grails/plugins/rx/RenderSpec.groovy b/src/test/groovy/org/grails/plugins/rx/RenderSpec.groovy
@@ -131,10 +131,44 @@ class RenderSpec extends Specification {
         RequestContextHolder.setRequestAttributes(null)
 
     }
+
+
+    void "Test render a from body async"() {
+        setup:
+        GrailsWebRequest webRequest = GrailsWebMockUtil.bindMockWebRequest()
+        MockHttpServletRequest request = webRequest.getCurrentRequest()
+        request.setAsyncSupported(true)
+        RenderController controller = new RenderController()
+        request.setAttribute(GrailsApplicationAttributes.CONTROLLER, controller)
+        request.setContent("Foo".bytes)
+        when:"A controller uses the render method and a string"
+        Observable observable = controller.renderFromBody()
+
+        then:
+        observable != null
+
+        when:"The observable is transformed"
+        RxResultTransformer transformer = new RxResultTransformer()
+        def result = transformer.transformActionResult(webRequest, "renderText", observable)
+        then:"null is returned"
+        result == null
+        webRequest.response.contentAsString == "Foo"
+
+        cleanup:
+        ConvertersConfigurationHolder.clear()
+        RequestContextHolder.setRequestAttributes(null)
+
+    }
 }
 
 class RenderController implements Controller {
 
+    def renderFromBody() {
+        fromBody(request)
+            .map { InputStream input ->
+            render(input.text)
+        }
+    }
     def renderView() {
         Observable.just("Foo")
                 .map { String result ->

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ You then may want to include an implementation of RxGORM, for the examples in th`
`16`	`16`	`----`
`17`	`17`	`dependencies {`
`18`	`18`	`...`
`19`		`- compile 'org.grails.plugins:rx-mongodb:6.0.0.M2'`
	`19`	`+ compile 'org.grails.plugins:rx-mongodb:6.0.7'`
`20`	`20`	`}`
`21`	`21`	`----`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,8 @@ import org.grails.web.servlet.mvc.GrailsWebRequest`
`13`	`13`	`import org.grails.web.util.GrailsApplicationAttributes`
`14`	`14`	`import org.springframework.mock.web.MockHttpServletRequest`
`15`	`15`	`import org.springframework.web.context.request.RequestContextHolder`
	`16`	`+import rx.Emitter`
	`17`	`+import rx.Observer`
`16`	`18`	`import rx.Subscriber`
`17`	`19`	`import spock.lang.Specification`
`18`	`20`
`@@ -126,23 +128,23 @@ class EventController implements Controller, RestResponder{`
`126`	`128`	`RxHelper rx = new RxHelper()`
`127`	`129`
`128`	`130`	`def stream() {`
`129`		`- rx.stream { Subscriber subscriber ->`
	`131`	`+ rx.stream { Observer observer ->`
`130`	`132`	`for(i in 0..3) {`
`131`		`- subscriber.onNext(`
	`133`	`+ observer.onNext(`
`132`	`134`	`rx.event("Foo $i\nFoo\nBar\nBaz", event: "Event $i", comment: 'potato', id: "$i")`
`133`	`135`	`)`
`134`	`136`	`}`
`135`		`- subscriber.onCompleted()`
	`137`	`+ observer.onCompleted()`
`136`	`138`	`}`
`137`	`139`	`}`
`138`	`140`
`139`	`141`	`def streamJson() {`
`140`		`- rx.stream { Subscriber subscriber ->`
	`142`	`+ rx.stream { Emitter emitter ->`
`141`	`143`	`for(i in 0..3) {`
`142`	`144`	`def foo = """bar $i`
`143`	`145`	`bar $i"""`
`144`	`146`	`def json = [foo: foo, 'baz': 3] as JSON`
`145`		`- subscriber.onNext(`
	`147`	`+ emitter.onNext(`
`146`	`148`	`rx.event(new Writable() {`
`147`	`149`	`@Override`
`148`	`150`	`Writer writeTo(Writer writer) throws IOException {`
`@@ -151,7 +153,7 @@ bar $i"""`
`151`	`153`	`}, id: "$i", retry: 1000)`
`152`	`154`	`)`
`153`	`155`	`}`
`154`		`- subscriber.onCompleted()`
	`156`	`+ emitter.onCompleted()`
`155`	`157`	`}`
`156`	`158`	`}`
`157`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ import org.grails.web.servlet.mvc.GrailsWebRequest`
`14`	`14`	`import org.grails.web.util.GrailsApplicationAttributes`
`15`	`15`	`import org.springframework.mock.web.MockHttpServletRequest`
`16`	`16`	`import org.springframework.web.context.request.RequestContextHolder`
	`17`	`+import rx.Emitter`
`17`	`18`	`import rx.Subscriber`
`18`	`19`	`import spock.lang.Specification`
`19`	`20`	`import static grails.rx.web.Rx.*`
`@@ -119,35 +120,35 @@ data: {"foo":"bar 3"}`
`119`	`120`	`}`
`120`	`121`	`class NewObservableController implements Controller, RestResponder{`
`121`	`122`	`def index() {`
`122`		`- create { Subscriber subscriber ->`
`123`		`- subscriber.onNext(`
	`123`	`+ create { Emitter emitter ->`
	`124`	`+ emitter.onNext(`
`124`	`125`	`render("Foo")`
`125`	`126`	`)`
`126`		`- subscriber.onCompleted()`
	`127`	`+ emitter.onCompleted()`
`127`	`128`	`}`
`128`	`129`	`}`
`129`	`130`
`130`	`131`	`def stream() {`
`131`		`- stream { Subscriber subscriber ->`
	`132`	`+ stream { Emitter emittter ->`
`132`	`133`	`for(i in 0..3) {`
`133`		`- subscriber.onNext(`
	`134`	`+ emittter.onNext(`
`134`	`135`	`render("Foo $i")`
`135`	`136`	`)`
`136`	`137`	`}`
`137`		`- subscriber.onCompleted()`
	`138`	`+ emittter.onCompleted()`
`138`	`139`	`}`
`139`	`140`	`}`
`140`	`141`
`141`	`142`	`def streamJson() {`
`142`		`- stream { Subscriber subscriber ->`
	`143`	`+ stream { Emitter emitter ->`
`143`	`144`	`for(i in 0..3) {`
`144`		`- subscriber.onNext(`
	`145`	`+ emitter.onNext(`
`145`	`146`	`render(contentType:"application/json") {`
`146`	`147`	`foo "bar $i"`
`147`	`148`	`}`
`148`	`149`	`)`
`149`	`150`	`}`
`150`		`- subscriber.onCompleted()`
	`151`	`+ emitter.onCompleted()`
`151`	`152`	`}`
`152`	`153`	`}`
`153`	`154`	`}`