Merge pull request #4847 from microsoft/miller/devops-1803723

Bug 1803723: [Bug][AzureToolkit][Test] Error box begin with failed to load/refresh items of combo box

Author: wangmingliang-ms

PluginsAndFeatures/azure-toolkit-for-intellij/src/com/microsoft/azure/toolkit/intellij/common/handler/IntelliJAzureExceptionHandler.java

@@ -29,6 +29,8 @@
 import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ModalityState;
+import com.intellij.openapi.progress.ProgressIndicator;
+import com.intellij.openapi.progress.ProgressManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.util.ui.UIUtil;
 import com.microsoft.azure.toolkit.intellij.common.AzureToolkitErrorDialog;
@@ -46,10 +48,8 @@
 import org.apache.commons.lang3.StringUtils;
 
 import java.awt.*;
-import java.util.HashMap;
 import java.util.List;
-import java.util.ListIterator;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -70,8 +70,9 @@ public void handleException(Project object, Throwable throwable, boolean isBackG
 
     @Override
     protected void onHandleException(final Throwable throwable, final @Nullable AzureExceptionAction[] actions) {
-        // todo: detect foreground/background from call stack
-        onHandleException(throwable, false, actions);
+        final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
+        final boolean background = Objects.isNull(indicator) || !indicator.isModal();
+        onHandleException(throwable, background, actions);
     }
 
     @Override

Utils/azuretools-core/src/com/microsoft/azure/toolkit/lib/common/handler/AzureExceptionHandler.java

@@ -22,10 +22,13 @@
 package com.microsoft.azure.toolkit.lib.common.handler;
 
 import com.microsoft.azuretools.azurecommons.helpers.Nullable;
+import lombok.extern.java.Log;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 
 import java.io.InterruptedIOException;
+import java.util.logging.Level;
 
+@Log
 public abstract class AzureExceptionHandler {
     private static AzureExceptionHandler handler;
 
@@ -53,11 +56,13 @@ public static void onRxException(final Throwable e) {
     }
 
     public void handleException(Throwable throwable, @Nullable AzureExceptionAction... action) {
+        log.log(Level.WARNING, "caught an error in AzureExceptionHandler", throwable);
         onHandleException(throwable, action);
     }
 
     public void handleException(Throwable throwable, boolean isBackGround, @Nullable AzureExceptionAction... action) {
-        onHandleException(throwable, isBackGround, action);
+        log.log(Level.WARNING, "caught an error in AzureExceptionHandler", throwable);
+        this.onHandleException(throwable, isBackGround, action);
     }
 
     protected abstract void onHandleException(Throwable throwable, @Nullable AzureExceptionAction[] action);

Utils/azuretools-core/src/com/microsoft/azure/toolkit/lib/common/operation/AzureOperationEnhancer.java

@@ -23,12 +23,17 @@
 package com.microsoft.azure.toolkit.lib.common.operation;
 
 import com.microsoft.azure.toolkit.lib.common.exception.AzureToolkitOperationException;
+import lombok.extern.java.Log;
 import org.apache.commons.collections4.CollectionUtils;
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.annotation.*;
 import org.aspectj.lang.reflect.MethodSignature;
 
+import java.util.Objects;
+import java.util.logging.Level;
+
 @Aspect
+@Log
 public final class AzureOperationEnhancer {
 
     @Pointcut("execution(@AzureOperation * *..*.*(..))")
@@ -40,15 +45,19 @@ public void enterOperation(JoinPoint point) {
         final AzureOperationRef operation = toOperationRef(point);
         final AzureOperation.Type type = AzureOperationUtils.getAnnotation(operation).type();
         if (type == AzureOperation.Type.ACTION) {
-            AzureOperationsContext.operations.get().clear();
+            AzureOperationsContext.clear();
         }
         AzureOperationsContext.push(operation);
     }
 
     @AfterReturning("operation()")
     public void exitOperation(JoinPoint point) {
-        if (CollectionUtils.isNotEmpty(AzureOperationsContext.operations.get())) {
-            AzureOperationsContext.pop();
+        final AzureOperationRef operation = toOperationRef(point);
+        if (CollectionUtils.isNotEmpty(AzureOperationsContext.getOperations())) {
+            final AzureOperationRef popped = AzureOperationsContext.pop();
+            if (!Objects.equals(popped, operation)) {
+                log.log(Level.SEVERE, "!!!operation stack is wrongly managed!!!");
+            }
         }
     }
 

Utils/azuretools-core/src/com/microsoft/azure/toolkit/lib/common/operation/AzureOperationRef.java

@@ -23,15 +23,26 @@
 package com.microsoft.azure.toolkit.lib.common.operation;
 
 import lombok.Builder;
-import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
 
 import java.lang.reflect.Method;
 
-@Data
+@Getter
+@Setter
 @Builder
 public class AzureOperationRef {
     private Method method;
     private String[] paramNames;
     private Object[] paramValues;
     private Object instance;
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (!(obj instanceof AzureOperationRef)) {
+            return false;
+        }
+        final AzureOperationRef operation = (AzureOperationRef) obj;
+        return operation.getMethod() == this.method || operation.getMethod().equals(this.method);
+    }
 }

Utils/azuretools-core/src/com/microsoft/azure/toolkit/lib/common/operation/AzureOperationsContext.java

@@ -23,85 +23,84 @@
 package com.microsoft.azure.toolkit.lib.common.operation;
 
 import com.microsoft.azure.toolkit.lib.common.handler.AzureExceptionHandler;
+import com.microsoft.azuretools.azurecommons.helpers.Nullable;
 import rx.Completable;
 import rx.Observable;
 import rx.Single;
+import rx.functions.Action1;
 
 import java.lang.Thread.UncaughtExceptionHandler;
 import java.util.*;
 
 public class AzureOperationsContext {
-    static final ThreadLocal<Deque<AzureOperationRef>> operations = ThreadLocal.withInitial(ArrayDeque::new);
-    static final UncaughtExceptionHandler rxExceptionHandler = (t, e) -> AzureExceptionHandler.onRxException(e);
-    static final UncaughtExceptionHandler exceptionHandler = (t, e) -> AzureExceptionHandler.onUncaughtException(e);
+    private static final ThreadLocal<Deque<AzureOperationRef>> operations = ThreadLocal.withInitial(ArrayDeque::new);
+    private static final UncaughtExceptionHandler rxExceptionHandler = (t, e) -> AzureExceptionHandler.onRxException(e);
+    private static final UncaughtExceptionHandler exceptionHandler = (t, e) -> AzureExceptionHandler.onUncaughtException(e);
 
     public static List<AzureOperationRef> getOperations() {
-        final ArrayList<AzureOperationRef> ops = new ArrayList<>(operations.get());
+        final ArrayList<AzureOperationRef> ops = new ArrayList<>(AzureOperationsContext.operations.get());
         Collections.reverse(ops);
         return Collections.unmodifiableList(ops);
     }
 
+    static void init(Deque<AzureOperationRef> closure) {
+        AzureOperationsContext.operations.set(closure);
+    }
+
     static void push(final AzureOperationRef operation) {
-        operations.get().push(operation);
+        AzureOperationsContext.operations.get().push(operation);
+    }
+
+    static AzureOperationRef pop() {
+        return AzureOperationsContext.operations.get().pop();
     }
 
-    static void pop() {
-        operations.get().pop();
+    static void clear() {
+        AzureOperationsContext.operations.get().clear();
+    }
+
+    static void dispose() {
+        AzureOperationsContext.operations.remove();
     }
 
     public static Runnable deriveClosure(final Runnable runnable) {
         final Deque<AzureOperationRef> closure = new ArrayDeque<>(AzureOperationsContext.getOperations());
-        return () -> {
-            operations.set(closure);
-            try {
-                runnable.run();
-            } catch (final Throwable throwable) {
-                AzureExceptionHandler.onUncaughtException(throwable);
-            }
-        };
+        final long parentThread = Thread.currentThread().getId();
+        return () -> act((none) -> runnable.run(), closure, parentThread, null);
     }
 
     public static Single.OnSubscribe<?> deriveClosure(final Single.OnSubscribe<?> action) {
         final Deque<AzureOperationRef> closure = new ArrayDeque<>(AzureOperationsContext.getOperations());
-        return (o) -> {
-            Thread.currentThread().setUncaughtExceptionHandler(rxExceptionHandler);
-            operations.set(closure);
-            try {
-                action.call(o);
-            } catch (final Throwable throwable) {
-                AzureExceptionHandler.onRxException(throwable);
-            }
-        };
+        final long parentThread = Thread.currentThread().getId();
+        return (o) -> act(action, closure, parentThread, o);
     }
 
     public static Observable.OnSubscribe<?> deriveClosure(final Observable.OnSubscribe<?> action) {
         final Deque<AzureOperationRef> closure = new ArrayDeque<>(AzureOperationsContext.getOperations());
-        return (o) -> {
-            Thread.currentThread().setUncaughtExceptionHandler(rxExceptionHandler);
-            operations.set(closure);
-            try {
-                action.call(o);
-            } catch (final Throwable throwable) {
-                AzureExceptionHandler.onRxException(throwable);
-            }
-        };
+        final long parentThread = Thread.currentThread().getId();
+        return (o) -> act(action, closure, parentThread, o);
     }
 
     public static Completable.OnSubscribe deriveClosure(final Completable.OnSubscribe action) {
         final Deque<AzureOperationRef> closure = new ArrayDeque<>(AzureOperationsContext.getOperations());
-        return (o) -> {
-            Thread.currentThread().setUncaughtExceptionHandler(rxExceptionHandler);
-            operations.set(closure);
-            try {
-                action.call(o);
-            } catch (final Throwable throwable) {
-                AzureExceptionHandler.onRxException(throwable);
-            }
-        };
+        final long parentThread = Thread.currentThread().getId();
+        return (o) -> act(action, closure, parentThread, o);
     }
 
-    @FunctionalInterface
-    public interface OperationProceedable {
-        Object proceed() throws Throwable;
+    private static void act(final Action1 action, final Deque<AzureOperationRef> closure, final long parentThread, @Nullable final Object subscriber) {
+        final long currentThread = Thread.currentThread().getId();
+        if (!Objects.equals(currentThread, parentThread)) {
+            Thread.currentThread().setUncaughtExceptionHandler(rxExceptionHandler);
+            AzureOperationsContext.init(closure);
+        }
+        try {
+            action.call(subscriber);
+        } catch (final Throwable throwable) {
+            AzureExceptionHandler.onRxException(throwable);
+        } finally {
+            if (!Objects.equals(currentThread, parentThread)) {
+                AzureOperationsContext.dispose();
+            }
+        }
     }
 }