added support for task state handling

.github/workflows/build-and-publish.yml

@@ -0,0 +1,38 @@
+# This workflow will build a package using Maven and then publish it to GitHub packages when a release is created
+# For more information see: https://github.com/actions/setup-java/blob/main/docs/advanced-usage.md#apache-maven-with-a-settings-path
+
+name: Build and publish
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 8
+        uses: actions/setup-java@v2
+        with:
+          java-version: '8'
+          distribution: 'zulu'
+          server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
+          # settings-path: ${{ github.workspace }} # location for the settings.xml file
+
+      - name: Build with Maven
+        run: mvn -B package --file pom.xml
+
+      - name: Publish to GitHub Packages Apache Maven
+        # run: mvn deploy -s $GITHUB_WORKSPACE/settings.xml
+        run: mvn --batch-mode deploy
+        env:
+          GITHUB_TOKEN: ${{ github.token }}

README.md

@@ -5,6 +5,11 @@
 
 # Async Manager for Vaadin Flow
 
+# Hinweis "c-si" Version
+Bei der Ausführung der Async-Tasks werden die Session und der SecurityContext der jeweiligen UI an den "Background-Thread" gesetzt.
+
+# About
+
 In complex application quite often you end up having a view that takes ages to load
 because some parts of view require heavy computation. If you are pursuing the goal 
 of making your application responsive, you would probably want to defer updates for
@@ -85,6 +90,11 @@ AsyncManager.getInstance().setExceptionHandler((task, exception) -> ...);
 Note: By default all worker threads are started by `ThreadPoolExecutor` which defaults
 to pool size of 25 threads. You can change that with `AsyncManager.getInstance().setExecutorService()`.
 
+As of version 1.2 it is possible to set a task state handler if you need more information about each task, e.g. for ui loading indicator handling.
+```java
+AsyncManager.getInstance().setTaskStateHandler((task, state) -> ...);
+```
+
 ## Installing with Maven
 
 ```xml

pom.xml

@@ -3,11 +3,11 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
-    <groupId>org.vaadin.helper</groupId>
+    <groupId>de.csi.vaadin.helper</groupId>
     <artifactId>async-manager</artifactId>
-    <version>1.1.0</version>
+    <version>1.2.1</version>
     <name>Async Manager</name>
-    <description>Async Manager for Vaadin Flow</description>
+    <description>Async Manager for Vaadin Flow (CSI fork)</description>
 
     <properties>
         <vaadin.version>10.0.5</vaadin.version>
@@ -38,6 +38,13 @@
             </dependency>
         </dependencies>
     </dependencyManagement>
+    <distributionManagement>
+        <repository>
+            <id>github</id>
+            <name>GitHub Packages</name>
+            <url>https://maven.pkg.github.com/c-si/async-manager</url>
+        </repository>
+    </distributionManagement>
 
     <repositories>
         <repository>
@@ -55,6 +62,18 @@
             <groupId>com.vaadin</groupId>
             <artifactId>vaadin-core</artifactId>
         </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>servlet-api</artifactId>
+            <version>2.5</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-web</artifactId>
+            <version>5.5.3</version>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-simple</artifactId>

src/main/java/org/vaadin/flow/helper/AsyncManager.java

@@ -5,7 +5,10 @@
 import com.vaadin.flow.component.ComponentUtil;
 import com.vaadin.flow.component.UI;
 
-import java.util.*;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
@@ -60,6 +63,11 @@ public final class AsyncManager {
      * Exception handler
      */
     private ExceptionHandler exceptionHandler = AsyncManager::logException;
+    /**
+     * Task state handler
+     */
+    private TaskStateHandler taskStateHandler;
+
     /**
      * Instance of {@link ExecutorService} used for asynchronous tasks
      */
@@ -132,6 +140,15 @@ public void setExceptionHandler(ExceptionHandler handler) {
         exceptionHandler = handler;
     }
 
+    /**
+     * Set custom task state handler to monitor
+     * @param handler State handler to set
+     */
+    public void setTaskStateHandler(TaskStateHandler handler) {
+        taskStateHandler = handler;
+    }
+
+
     /**
      * Get a {@link ExecutorService} used for asynchronous task execution.
      *
@@ -294,6 +311,12 @@ void handleException(Task task, Exception e) {
         exceptionHandler.handle(task, e);
     }
 
+    void handleTaskStateChanged(Task task, TaskStateHandler.State state) {
+        if (taskStateHandler != null) {
+            taskStateHandler.taskChanged(task, state);
+        }
+    }
+
     /**
      * Functional interface for exception handling
      */
@@ -307,4 +330,32 @@ public interface ExceptionHandler {
          */
         void handle(Task task, Exception e);
     }
+
+    /**
+     * Functional interface for task state handling
+     */
+    @FunctionalInterface
+    public interface TaskStateHandler {
+        enum State {
+            /**
+             * Task started
+             */
+            RUNNING,
+            /**
+             * Task done
+             */
+            DONE,
+            /**
+             * Task was canceled
+             */
+            CANCELED
+        }
+
+        /**
+         * Handle state change during task execution.
+         * @param task Task where state change happened
+         * @param state State of the given task
+         */
+        void taskChanged(Task task, State state);
+    }
 }

src/main/java/org/vaadin/flow/helper/AsyncTask.java

@@ -3,8 +3,12 @@
 import com.vaadin.flow.component.*;
 import com.vaadin.flow.router.BeforeLeaveEvent;
 import com.vaadin.flow.server.Command;
+import com.vaadin.flow.server.VaadinSession;
 import com.vaadin.flow.shared.Registration;
 import com.vaadin.flow.shared.communication.PushMode;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
@@ -50,7 +54,7 @@ public class AsyncTask extends Task {
      * Number of poll events happened while action is executing, or {@link #PUSH_ACTIVE} if
      * push is used for current task
      */
-    private AtomicInteger missedPolls = new AtomicInteger();
+    private final AtomicInteger missedPolls = new AtomicInteger();
     /**
      * {@code true}, if thread may be interrupted if UI/Component detaches
      */
@@ -100,6 +104,7 @@ public void cancel() {
         if (!task.isCancelled() && !task.isDone()) {
             task.cancel(mayInterrupt);
         }
+        getAsyncManager().handleTaskStateChanged(this, AsyncManager.TaskStateHandler.State.CANCELED);
         remove();
     }
 
@@ -191,6 +196,12 @@ private void registerPoll(Component component, Action action) {
     private FutureTask<AsyncTask> createFutureTask(Action action) {
         return new FutureTask<>(() -> {
             try {
+                getAsyncManager().handleTaskStateChanged(this, AsyncManager.TaskStateHandler.State.RUNNING);
+
+                // Session + Security für den Async-Task setzen
+                VaadinSession.setCurrent(getUI().getSession());
+                SecurityContextHolder.setContext((SecurityContext) VaadinSession.getCurrent().getSession().getAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY));
+
                 action.run(this);
             } catch (UIDetachedException ignore) {
                 // Do not report
@@ -201,6 +212,7 @@ private FutureTask<AsyncTask> createFutureTask(Action action) {
                 // Dump
                 getAsyncManager().handleException(this, e);
             } finally {
+                getAsyncManager().handleTaskStateChanged(this, AsyncManager.TaskStateHandler.State.DONE);
                 remove();
             }
         }, this);

src/main/java/org/vaadin/flow/helper/SyncTask.java

@@ -69,10 +69,13 @@ public void preventThreadInterrupt() {
     void register(UI ui, Component component, Action action) {
         setUI(ui);
         try {
+            getAsyncManager().handleTaskStateChanged(this, AsyncManager.TaskStateHandler.State.RUNNING);
             action.run(this);
+            getAsyncManager().handleTaskStateChanged(this, AsyncManager.TaskStateHandler.State.DONE);
         } catch (Exception e) {
             // Dump
             getAsyncManager().handleException(this, e);
+            getAsyncManager().handleTaskStateChanged(this, AsyncManager.TaskStateHandler.State.DONE);
         }
     }
 }