Avoid slow operation

src/main/java/org/sonarlint/intellij/SonarLintIntelliJClient.kt

@@ -391,9 +391,9 @@ object SonarLintIntelliJClient : SonarLintClient {
 
  override fun getCredentials(params: GetCredentialsParams): CompletableFuture<GetCredentialsResponse> {
  val connectionId = params.connectionId
- return ServerConnectionService.getInstance().getServerConnectionByName(connectionId)
- .map { connection -> connection.credentials.token?.let { CompletableFuture.completedFuture(GetCredentialsResponse(TokenDto(it))) }
- ?: connection.credentials.login?.let { CompletableFuture.completedFuture(GetCredentialsResponse(UsernamePasswordDto(it, connection.credentials.password))) }
+ return ServerConnectionService.getInstance().getServerCredentialsByName(connectionId)
+ .map { credentials -> credentials.token?.let { CompletableFuture.completedFuture(GetCredentialsResponse(TokenDto(it))) }
+ ?: credentials.login?.let { CompletableFuture.completedFuture(GetCredentialsResponse(UsernamePasswordDto(it, credentials.password))) }
  ?: CompletableFuture.failedFuture(IllegalArgumentException("Invalid credentials for connection: $connectionId"))}
  .orElseGet { CompletableFuture.failedFuture(IllegalArgumentException("Connection '$connectionId' not found")) }
  }

src/main/java/org/sonarlint/intellij/config/global/ServerConnection.kt

@@ -34,7 +34,6 @@ sealed class ServerConnection {
  abstract val name: String
  abstract val notificationsDisabled: Boolean
  abstract val hostUrl: String
- abstract val credentials: ServerConnectionCredentials
  abstract val product: SonarProduct
  abstract val links: ServerLinks
  abstract val endpointParams: EndpointParams
@@ -45,14 +44,13 @@ sealed class ServerConnection {
  val productName get() = product.productName
 }
 
-data class SonarQubeConnection(override val name: String, override val hostUrl: String, override val credentials: ServerConnectionCredentials, override val notificationsDisabled: Boolean) : ServerConnection() {
+data class SonarQubeConnection(override val name: String, override val hostUrl: String, override val notificationsDisabled: Boolean) : ServerConnection() {
  override val product = SonarProduct.SONARQUBE
  override val links = SonarQubeLinks(hostUrl)
  override val endpointParams = EndpointParams(hostUrl, false, null)
 }
 
-data class SonarCloudConnection(override val name: String, val token: String, val organizationKey: String, override val notificationsDisabled: Boolean) : ServerConnection() {
- override val credentials = ServerConnectionCredentials(null, null, token)
+data class SonarCloudConnection(override val name: String, val organizationKey: String, override val notificationsDisabled: Boolean) : ServerConnection() {
  override val product = SonarProduct.SONARCLOUD
  override val links = SonarCloudLinks
  override val hostUrl: String = SONARCLOUD_URL

src/main/java/org/sonarlint/intellij/config/global/ServerConnectionCredentialsNotFound.kt

@@ -0,0 +1,3 @@
+package org.sonarlint.intellij.config.global
+
+class ServerConnectionCredentialsNotFound(connectionName: String) : RuntimeException("Unable to load credentials for connection '$connectionName'")

src/main/java/org/sonarlint/intellij/config/global/ServerConnectionMgmtPanel.java

@@ -20,6 +20,7 @@
 package org.sonarlint.intellij.config.global;
 
 import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.ModalityState;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ProjectManager;
 import com.intellij.openapi.ui.Messages;
@@ -36,8 +37,10 @@
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -53,6 +56,8 @@
 
 import static org.sonarlint.intellij.common.util.SonarLintUtils.getService;
 import static org.sonarlint.intellij.config.Settings.getSettingsFor;
+import static org.sonarlint.intellij.ui.UiUtils.runOnUiThread;
+import static org.sonarlint.intellij.util.ThreadUtilsKt.runOnPooledThread;
 
 public class ServerConnectionMgmtPanel implements ConfigurationPanel<SonarLintGlobalSettings> {
  private static final String LABEL_NO_SERVERS = "Add a connection to SonarQube or SonarCloud";
@@ -64,8 +69,10 @@ public class ServerConnectionMgmtPanel implements ConfigurationPanel<SonarLintGl
 
  // Model
  private GlobalConfigurationListener connectionChangeListener;
- private final List<ServerConnection> connections = new ArrayList<>();
+ private final Map<String, ServerConnectionWithAuth> updatedConnectionsByName = new HashMap<>();
+ private final Map<String, ServerConnectionWithAuth> addedConnectionsByName = new HashMap<>();
  private final Set<String> deletedServerIds = new HashSet<>();
+ private CollectionListModel<ServerConnection> listModel;
 
  private void create() {
  var app = ApplicationManager.getApplication();
@@ -139,29 +146,35 @@ public JComponent getComponent() {
 
  @Override
  public boolean isModified(SonarLintGlobalSettings settings) {
- return !connections.equals(ServerConnectionService.getInstance().getConnections());
+ return !updatedConnectionsByName.isEmpty() || !addedConnectionsByName.isEmpty() || !deletedServerIds.isEmpty();
  }
 
  @Override
  public void save(SonarLintGlobalSettings newSettings) {
- ServerConnectionService.getInstance().setServerConnections(newSettings, connections);
- // remove them even if a server with the same name was later added
- unbindRemovedServers();
+ // use background thread because of credentials save
+ runOnPooledThread(() -> {
+ ServerConnectionService.getInstance().updateServerConnections(newSettings, new HashSet<>(deletedServerIds), new ArrayList<>(updatedConnectionsByName.values()),
+ new ArrayList<>(addedConnectionsByName.values()));
+ // remove them even if a server with the same name was later added
+ unbindRemovedServers();
+ });
+
  }
 
  @Override
  public void load(SonarLintGlobalSettings settings) {
- connections.clear();
+ updatedConnectionsByName.clear();
+ addedConnectionsByName.clear();
  deletedServerIds.clear();
 
- var listModel = new CollectionListModel<ServerConnection>(new ArrayList<>());
+ listModel = new CollectionListModel<>(new ArrayList<>());
  var serverConnections = ServerConnectionService.getInstance().getConnections();
+
  listModel.add(serverConnections);
- connections.addAll(serverConnections);
  connectionList.setModel(listModel);
 
- if (!connections.isEmpty()) {
- connectionList.setSelectedValue(connections.get(0), true);
+ if (!serverConnections.isEmpty()) {
+ connectionList.setSelectedValue(serverConnections.get(0), true);
  }
  }
 
@@ -171,35 +184,64 @@ private ServerConnection getSelectedConnection() {
  }
 
  List<ServerConnection> getConnections() {
- return connections;
+ return listModel.getItems();
  }
 
  private void editSelectedConnection() {
  var selectedConnection = getSelectedConnection();
  int selectedIndex = connectionList.getSelectedIndex();
 
  if (selectedConnection != null) {
- var serverEditor = ServerConnectionWizard.forConnectionEdition(selectedConnection);
- if (serverEditor.showAndGet()) {
- var editedConnection = serverEditor.getConnection();
- ((CollectionListModel<ServerConnection>) connectionList.getModel()).setElementAt(editedConnection, selectedIndex);
- connections.set(connections.indexOf(selectedConnection), editedConnection);
- connectionChangeListener.changed(connections);
- }
+ var connectionName = selectedConnection.getName();
+ runOnPooledThread(() -> {
+ var previousCredentials = getCredentialsForEdition(connectionName);
+ runOnUiThread(ModalityState.any(), () -> {
+ var serverEditor = ServerConnectionWizard.forConnectionEdition(new ServerConnectionWithAuth(selectedConnection, previousCredentials));
+ if (serverEditor.showAndGet()) {
+ var editedConnectionWithAuth = serverEditor.getConnectionWithAuth();
+ listModel.setElementAt(editedConnectionWithAuth.getConnection(), selectedIndex);
+ if (addedConnectionsByName.containsKey(connectionName)) {
+ addedConnectionsByName.put(connectionName, editedConnectionWithAuth);
+ } else {
+ updatedConnectionsByName.put(connectionName, editedConnectionWithAuth);
+ }
+ connectionChangeListener.changed(getConnections());
+ }
+ });
+ });
+ }
+ }
+
+ private ServerConnectionCredentials getCredentialsForEdition(String connectionName) {
+ var connection = addedConnectionsByName.get(connectionName);
+ if (connection != null) {
+ return connection.getCredentials();
+ }
+ connection = updatedConnectionsByName.get(connectionName);
+ if (connection != null) {
+ return connection.getCredentials();
  }
+ return ServerConnectionService.getInstance().getServerCredentialsByName(connectionName)
+ .orElseThrow(() -> new IllegalStateException("Credentials for connection '" + connectionName + "' not found"));
  }
 
  private class AddConnectionAction implements AnActionButtonRunnable {
  @Override
  public void run(AnActionButton anActionButton) {
- var existingNames = connections.stream().map(ServerConnection::getName).collect(Collectors.toSet());
+ var existingNames = getConnections().stream().map(ServerConnection::getName).collect(Collectors.toSet());
  var wizard = ServerConnectionWizard.forNewConnection(existingNames);
  if (wizard.showAndGet()) {
- var created = wizard.getConnection();
- connections.add(created);
- ((CollectionListModel<ServerConnection>) connectionList.getModel()).add(created);
- connectionList.setSelectedIndex(connectionList.getModel().getSize() - 1);
- connectionChangeListener.changed(connections);
+ var created = wizard.getConnectionWithAuth();
+ var connectionName = created.getConnection().getName();
+ if (deletedServerIds.contains(connectionName)) {
+ updatedConnectionsByName.put(connectionName, created);
+ deletedServerIds.remove(connectionName);
+ } else {
+ addedConnectionsByName.put(connectionName, created);
+ }
+ listModel.add(created.getConnection());
+ connectionList.setSelectedIndex(listModel.getSize() - 1);
+ connectionChangeListener.changed(getConnections());
  }
  }
  }
@@ -228,15 +270,18 @@ public void run(AnActionButton anActionButton) {
  }
  }
 
- var model = (CollectionListModel<ServerConnection>) connectionList.getModel();
- // it's not removed from serverIds and editorList
- model.remove(connection);
- connections.remove(connection);
- connectionChangeListener.changed(connections);
+ listModel.remove(connection);
+ var connectionName = connection.getName();
+ if (!addedConnectionsByName.containsKey(connectionName)) {
+ deletedServerIds.add(connectionName);
+ }
+ addedConnectionsByName.remove(connectionName);
+ updatedConnectionsByName.remove(connectionName);
+ connectionChangeListener.changed(getConnections());
 
- if (model.getSize() > 0) {
- var newIndex = Math.min(model.getSize() - 1, Math.max(selectedIndex - 1, 0));
- connectionList.setSelectedValue(model.getElementAt(newIndex), true);
+ if (listModel.getSize() > 0) {
+ var newIndex = Math.min(listModel.getSize() - 1, Math.max(selectedIndex - 1, 0));
+ connectionList.setSelectedValue(listModel.getElementAt(newIndex), true);
  }
  }