Merge grace-plugin-async into the framework

Author: rainboyan

grace-plugin-async/README.md

@@ -0,0 +1,2 @@
+## grails-plugin-async
+

grace-plugin-async/app/.gitkeep

@@ -0,0 +1,19 @@
+dependencies {
+    compileOnly "jakarta.servlet:jakarta.servlet-api"
+    implementation "org.graceframework:grace-plugin-controllers"
+    api project(':grace-async-core')
+
+    api("org.springframework.boot:spring-boot-autoconfigure")
+    annotationProcessor("org.springframework.boot:spring-boot-autoconfigure-processor")
+    annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
+
+    testImplementation "jakarta.servlet:jakarta.servlet-api"
+    testImplementation "org.graceframework:grace-test"
+    testImplementation "org.springframework:spring-test"
+}
+
+jar {
+    enabled = true
+    archiveClassifier.set('plugin')
+    includeEmptyDirs = false
+}

grace-plugin-async/build.gradle

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2013 SpringSource
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package grails.async.services
+
+import groovy.transform.CompileStatic
+import grails.persistence.support.PersistenceContextInterceptorExecutor
+import grails.async.decorator.PromiseDecorator
+
+/**
+ * A {@link PromiseDecorator} that wraps a promise execution in a persistence context (example Hibernate session)
+ *
+ * @author Graeme Rocher
+ * @since 2.3
+ */
+@CompileStatic
+class PersistenceContextPromiseDecorator implements PromiseDecorator{
+    PersistenceContextInterceptorExecutor persistenceContextInterceptorExecutor
+
+    PersistenceContextPromiseDecorator(PersistenceContextInterceptorExecutor persistenceContextInterceptorExecutor) {
+        this.persistenceContextInterceptorExecutor = persistenceContextInterceptorExecutor
+    }
+
+    @Override
+    def <D> Closure<D> decorate(Closure<D> original) {
+        if (persistenceContextInterceptorExecutor != null) {
+            return { args ->
+                try {
+                    persistenceContextInterceptorExecutor.initPersistenceContext()
+                    return original.call(args)
+                } finally {
+                    persistenceContextInterceptorExecutor.destroyPersistenceContext()
+                }
+            }
+        }
+        return original
+    }
+}

grace-plugin-async/src/main/groovy/grails/async/services/PersistenceContextPromiseDecorator.groovy

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2013 SpringSource
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package grails.async.services
+
+import groovy.transform.CompileStatic
+import org.springframework.beans.BeanWrapper
+import org.springframework.beans.MutablePropertyValues
+import org.springframework.beans.PropertyAccessorFactory
+
+import grails.async.decorator.PromiseDecorator
+//import org.springframework.beans.annotation.AnnotationBeanUtils
+import org.springframework.transaction.PlatformTransactionManager
+import org.springframework.transaction.TransactionDefinition
+import org.springframework.transaction.annotation.Transactional
+import org.springframework.transaction.support.DefaultTransactionDefinition
+import org.springframework.transaction.support.TransactionCallback
+import org.springframework.transaction.support.TransactionTemplate
+
+/**
+ * A {@link PromiseDecorator} that wraps a {@link grails.async.Promise} in a transaction
+ *
+ * @author Graeme Rocher
+ * @since 2.3
+ */
+@CompileStatic
+class TransactionalPromiseDecorator implements PromiseDecorator, TransactionDefinition {
+
+    PlatformTransactionManager transactionManager
+    @Delegate DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition()
+
+    TransactionalPromiseDecorator(PlatformTransactionManager transactionManager) {
+        this.transactionManager = transactionManager
+    }
+
+    TransactionalPromiseDecorator(PlatformTransactionManager transactionManager, DefaultTransactionDefinition transactionDefinition) {
+        this.transactionManager = transactionManager
+        this.transactionDefinition = transactionDefinition
+    }
+
+    TransactionalPromiseDecorator(PlatformTransactionManager transactionManager, Transactional transactionDefinition) {
+        this.transactionManager = transactionManager
+        final definition = new DefaultTransactionDefinition()
+//        AnnotationBeanUtils.copyPropertiesToBean(transactionDefinition, definition)
+        BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(definition)
+        bw.setPropertyValues(new MutablePropertyValues(transactionDefinition.getProperties()))
+        this.transactionDefinition = definition
+    }
+
+    @Override
+    def <D> Closure<D> decorate(Closure<D> original) {
+        if (transactionManager != null) {
+            return (Closure<D>){ args ->
+                def transactionTemplate = transactionDefinition != null ? new TransactionTemplate(transactionManager, transactionDefinition) : new TransactionTemplate(transactionManager)
+                transactionTemplate.execute({
+                    original.call(args)
+                } as TransactionCallback)
+            }
+        }
+        return original
+    }
+}

grace-plugin-async/src/main/groovy/grails/async/services/TransactionalPromiseDecorator.groovy

@@ -0,0 +1,39 @@
+package grails.async.web
+
+import org.grails.plugins.web.async.GrailsAsyncContext
+import org.grails.web.servlet.mvc.GrailsWebRequest
+import org.grails.web.util.GrailsApplicationAttributes
+import org.springframework.web.context.request.RequestContextHolder
+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 jakarta.servlet.AsyncContext
+import jakarta.servlet.http.HttpServletRequest
+
+/**
+ * Exposes a startAsync() method for access to the Servlet 3.x API
+ *
+ * @author Graeme Rocher
+ * @since 3.3
+ */
+trait AsyncController {
+    /**
+     * Raw access to the Servlet 3.0 startAsync method
+     *
+     * @return a new {@link jakarta.servlet.AsyncContext}
+     */
+    AsyncContext startAsync() {
+        GrailsWebRequest webRequest = (GrailsWebRequest)RequestContextHolder.currentRequestAttributes()
+
+        HttpServletRequest request = webRequest.currentRequest
+        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request)
+
+        AsyncWebRequest asyncWebRequest = new AsyncGrailsWebRequest(request, webRequest.currentResponse, webRequest.servletContext)
+        asyncManager.setAsyncWebRequest(asyncWebRequest)
+
+        asyncWebRequest.startAsync()
+        request.setAttribute(GrailsApplicationAttributes.ASYNC_STARTED, true)
+        new GrailsAsyncContext(asyncWebRequest.asyncContext, webRequest)
+    }
+}

grace-plugin-async/src/main/groovy/grails/async/web/AsyncController.groovy

@@ -0,0 +1,124 @@
+package grails.async.web
+
+import groovy.transform.CompileStatic
+import org.grails.web.util.GrailsApplicationAttributes
+import org.grails.web.servlet.mvc.GrailsWebRequest
+import org.springframework.context.ApplicationContext
+import org.springframework.util.Assert
+import org.springframework.web.context.request.async.AsyncWebRequest
+
+import jakarta.servlet.AsyncContext
+import jakarta.servlet.AsyncEvent
+import jakarta.servlet.AsyncListener
+import jakarta.servlet.ServletContext
+import jakarta.servlet.http.HttpServletRequest
+import jakarta.servlet.http.HttpServletResponse
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.function.Consumer
+
+/**
+ * Implementation of Spring 4.0 {@link AsyncWebRequest} interface for Grails
+ *
+ * @author Graeme Rocher
+ * @since 3.0
+ */
+@CompileStatic
+class AsyncGrailsWebRequest extends GrailsWebRequest implements AsyncWebRequest, AsyncListener{
+    static final String WEB_REQUEST = "org.grails.ASYNC_WEB_REQUEST"
+
+    Long timeout
+    AsyncContext asyncContext
+
+    private AtomicBoolean asyncCompleted = new AtomicBoolean(false)
+
+    List<Runnable> timeoutHandlers = []
+    List<Runnable> completionHandlers = []
+    List<Consumer<Throwable>> exceptionHandlers = []
+
+    AsyncGrailsWebRequest(HttpServletRequest request, HttpServletResponse response, GrailsApplicationAttributes attributes) {
+        super(request, response, attributes)
+        request.setAttribute(WEB_REQUEST, this)
+    }
+
+    AsyncGrailsWebRequest(HttpServletRequest request, HttpServletResponse response, ServletContext servletContext) {
+        super(request, response, servletContext)
+        request.setAttribute(WEB_REQUEST, this)
+    }
+
+    AsyncGrailsWebRequest(HttpServletRequest request, HttpServletResponse response, ServletContext servletContext, ApplicationContext applicationContext) {
+        super(request, response, servletContext, applicationContext)
+        request.setAttribute(WEB_REQUEST, this)
+    }
+
+    /**
+     * Looks up the GrailsWebRequest from the current request.
+     * @param request The current request
+     * @return The GrailsWebRequest
+     */
+    static AsyncGrailsWebRequest lookup(HttpServletRequest request) {
+        AsyncGrailsWebRequest webRequest = (AsyncGrailsWebRequest) request.getAttribute(WEB_REQUEST);
+        return webRequest
+    }
+
+    @Override
+    void addTimeoutHandler(Runnable runnable) {
+        timeoutHandlers << runnable
+    }
+
+    @Override
+    void addErrorHandler(Consumer<Throwable> exceptionHandler) {
+        exceptionHandlers << exceptionHandler
+    }
+
+    @Override
+    void addCompletionHandler(Runnable runnable) {
+        completionHandlers << runnable
+    }
+
+    @Override
+    void startAsync() {
+        Assert.state(request.asyncSupported, "The current request does not support Async processing")
+        if(!isAsyncStarted()) {
+            asyncContext = request.startAsync(request, response)
+            asyncContext.addListener(this)
+        }
+    }
+
+    @Override
+    boolean isAsyncStarted() {
+        asyncContext && request.asyncStarted
+    }
+
+    @Override
+    void dispatch() {
+       Assert.notNull this.asyncContext, "Cannot dispatch without an AsyncContext"
+       asyncContext.dispatch()
+    }
+
+    @Override
+    boolean isAsyncComplete() {
+        return this.asyncCompleted.get()
+    }
+
+    @Override
+    void onComplete(AsyncEvent event) throws IOException {
+        for(handler in completionHandlers) {
+            handler.run()
+        }
+        asyncContext = null
+        asyncCompleted.set true
+    }
+
+    @Override
+    void onTimeout(AsyncEvent event) throws IOException {
+        for(handler in timeoutHandlers) {
+            handler.run()
+        }
+    }
+
+    @Override
+    void onError(AsyncEvent event) throws IOException {}
+
+    @Override
+    void onStartAsync(AsyncEvent event) throws IOException {}
+}