Merge pull request #4848 from microsoft/release

shenqianjin · web-flow · commit 6eaf1b6729dc · 2020-12-24T16:14:02.000+08:00
Release
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -65,11 +65,11 @@ All notable changes to "Azure Toolkit for IntelliJ IDEA" will be documented in t
 ## 3.47.0
 
 ### Added
-- Add Azure MySQL support in Azure Toolkits
-  - Manage Azure MySQL instance (create/start/stop/restart/configure/show properties)
-  - Configure Azure MySQL to allow access it from azure services and local PC
-  - Show sample of JDBC connection strings on MySQL
-  - Open and connect to MySQL server by Intellij database tools
+- Add Azure Database for MySQL support in Azure Toolkits
+  - Manage Azure Database for MySQL instance (create/start/stop/restart/configure/show properties)
+  - Configure Azure Database for MySQL to allow access it from azure services and local PC
+  - Show sample of JDBC connection strings on Azure Database for MySQL
+  - Open and connect to Azure Database for MySQL server by Intellij database tools
 - Add Stacktrace filter in Spark console
 - Enable speed search in subscription table
 - Enable speed search in Azure explorer tree
diff --git a/PluginsAndFeatures/azure-toolkit-for-intellij/resources/META-INF/plugin.xml b/PluginsAndFeatures/azure-toolkit-for-intellij/resources/META-INF/plugin.xml
@@ -29,10 +29,10 @@
     <ul>
         <li>Add Azure MySQL support in Azure Toolkits
             <ul>
-                <li>Manage Azure MySQL instance (create/start/stop/restart/configure/show properties)</li>
-                <li>Configure Azure MySQL to allow access it from azure services and local PC</li>
-                <li>Show sample of JDBC connection strings on MySQL</li>
-                <li>Open and connect to MySQL server by Intellij database tools</li>
+                <li>Manage Azure Database for MySQL instance (create/start/stop/restart/configure/show properties)</li>
+                <li>Configure Azure Database for MySQL to allow access it from azure services and local PC</li>
+                <li>Show sample of JDBC connection strings on Azure Database for MySQL</li>
+                <li>Open and connect to Azure Database for MySQL server by Intellij database tools</li>
             </ul>
         </li>
         <li>Add Stacktrace filter in Spark console</li>
diff --git a/PluginsAndFeatures/azure-toolkit-for-intellij/resources/whatsnew/whatsnew.md b/PluginsAndFeatures/azure-toolkit-for-intellij/resources/whatsnew/whatsnew.md
@@ -4,11 +4,13 @@
 ## 3.47.0
 
 ### Added
-- Add Azure MySQL support in Azure Toolkits
-  - Manage Azure MySQL instance (create/start/stop/restart/configure/show properties)
-  - Configure Azure MySQL to allow access it from azure services and local PC
-  - Show sample of JDBC connection strings on MySQL
-  - Open and connect to MySQL server by Intellij database tools
+<img src="https://user-images.githubusercontent.com/19339116/102885897-15b30d00-448f-11eb-9733-ecbf77ee9760.gif" width="840" height="525" />
+
+- Add Azure Database for MySQL support in Azure Toolkits
+  - Manage Azure Database for MySQL instance (create/start/stop/restart/configure/show properties)
+  - Configure Azure Database for MySQL to allow access it from azure services and local PC
+  - Show sample of JDBC connection strings on Azure Database for MySQL
+  - Open and connect to Azure Database for MySQL server by Intellij database tools
 - Add Stacktrace filter in Spark console
 - Enable speed search in subscription table
 - Enable speed search in Azure explorer tree
diff --git a/PluginsAndFeatures/azure-toolkit-for-intellij/src/com/microsoft/azure/toolkit/intellij/common/handler/IntelliJAzureExceptionHandler.java b/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
diff --git a/PluginsAndFeatures/azure-toolkit-for-intellij/src/com/microsoft/azure/toolkit/intellij/mysql/creation/PasswordUtils.java b/PluginsAndFeatures/azure-toolkit-for-intellij/src/com/microsoft/azure/toolkit/intellij/mysql/creation/PasswordUtils.java
@@ -92,7 +92,9 @@ private static AzureValidationInfo validatePassword(String password, String user
         // validate longest common subsequence between username and password.
         LongestCommonSubsequence algorithm = new LongestCommonSubsequence();
         int longestCommonSubsequenceLength = algorithm.apply(username, password);
-        if (longestCommonSubsequenceLength >= LONGEST_COMMON_SUBSEQUENCE_BETWEEN_NAME_AND_PASSWORD) {
+        int usernameLength = StringUtils.length(username);
+        if ((usernameLength > 0 && longestCommonSubsequenceLength == usernameLength)
+                || longestCommonSubsequenceLength >= LONGEST_COMMON_SUBSEQUENCE_BETWEEN_NAME_AND_PASSWORD) {
             final AzureValidationInfo.AzureValidationInfoBuilder builder = AzureValidationInfo.builder();
             return builder.input(input).message("Your password cannot contain all or part of the login name." +
                     " Part of a login name is defined as three or more consecutive alphanumeric characters.")
diff --git a/PluginsAndFeatures/azure-toolkit-for-intellij/src/com/microsoft/intellij/forms/CreateRedisCacheForm.java b/PluginsAndFeatures/azure-toolkit-for-intellij/src/com/microsoft/intellij/forms/CreateRedisCacheForm.java
@@ -61,6 +61,7 @@
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.io.IOException;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -87,6 +88,7 @@ public class CreateRedisCacheForm extends AzureDialogWrapper {
     private JTextField txtNewResGrp;
     private JRadioButton rdoUseExist;
     private JComboBox<String> cbUseExist;
+    // TODO(qianjin) : use AzureComboBox
     private JComboBox<Location> cbLocations;
     private JComboBox<String> cbPricing;
     private JCheckBox chkNoSSL;
@@ -122,6 +124,11 @@ public class CreateRedisCacheForm extends AzureDialogWrapper {
     private static final String NEW_RES_GRP_ERROR_FORMAT = "The resource group: %s is already existed.";
     private static final String RES_GRP_NAME_RULE = "Resource group name can only allows up to 90 characters, include"
             + " alphanumeric characters, periods, underscores, hyphens and parenthesis and cannot end in a period.";
+    private static final List<String> SUPPORTED_REGIONS = Arrays.asList("centralus", "eastasia", "southeastasia", "eastus", "eastus2", "westus",
+            "westus2", "northcentralus", "southcentralus", "westcentralus", "northeurope", "westeurope", "japaneast", "japanwest", "brazilsouth",
+            "australiasoutheast", "australiaeast", "westindia", "southindia", "centralindia", "canadacentral", "canadaeast", "uksouth", "ukwest",
+            "koreacentral", "koreasouth", "francecentral", "southafricanorth", "uaenorth", "australiacentral", "switzerlandnorth", "germanywestcentral",
+            "norwayeast", "australiacentral2", "eastus2euap", "centraluseuap");
 
     public CreateRedisCacheForm(Project project) throws IOException {
         super(project, true);
@@ -398,7 +405,8 @@ public void customize(JList list, Object o, int i, boolean b, boolean b1) {
     private void fillLocationsAndResourceGrps(SubscriptionDetail selectedSub) {
         List<Location> locations = AzureModel.getInstance().getSubscriptionToLocationMap().get(selectedSub);
         if (locations != null) {
-            List<Location> sortedLocations = locations.stream().sorted(Comparator.comparing(Location::displayName)).collect(Collectors.toList());
+            List<Location> sortedLocations = locations.stream().filter(e -> SUPPORTED_REGIONS.contains(e.name()))
+                    .sorted(Comparator.comparing(Location::displayName)).collect(Collectors.toList());
             cbLocations.setModel(new DefaultComboBoxModel(sortedLocations.toArray()));
         }
         List<ResourceGroup> groups = AzureModel.getInstance().getSubscriptionToResourceGroupMap().get(selectedSub);
diff --git a/Utils/azure-explorer-common/src/com/microsoft/tooling/msservices/serviceexplorer/azure/function/FunctionModule.java b/Utils/azure-explorer-common/src/com/microsoft/tooling/msservices/serviceexplorer/azure/function/FunctionModule.java
@@ -52,12 +52,8 @@ public FunctionModule(Node parent) {
     @Override
     @AzureOperation(value = "remove function app", type = AzureOperation.Type.ACTION)
     public void removeNode(String sid, String id, Node node) {
-        try {
-            functionModulePresenter.onDeleteFunctionApp(sid, id);
-            removeDirectChildNode(node);
-        } finally {
-            functionModulePresenter.onModuleRefresh();
-        }
+        functionModulePresenter.onDeleteFunctionApp(sid, id);
+        removeDirectChildNode(node);
     }
 
     @Override
diff --git a/Utils/azuretools-core/src/com/microsoft/azure/toolkit/lib/common/handler/AzureExceptionHandler.java b/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);
diff --git a/Utils/azuretools-core/src/com/microsoft/azure/toolkit/lib/common/operation/AzureOperationEnhancer.java b/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!!!");
+            }
         }
     }
 
diff --git a/Utils/azuretools-core/src/com/microsoft/azure/toolkit/lib/common/operation/AzureOperationRef.java b/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);
+    }
 }
diff --git a/Utils/azuretools-core/src/com/microsoft/azure/toolkit/lib/common/operation/AzureOperationsContext.java b/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();
+            }
+        }
     }
 }
