force update

force user to update backend or plugin

Author: shalom938

build.gradle.kts

@@ -70,15 +70,14 @@ dependencies {
         "configuration" to "riderDotNetObjects")))
 }
 
-configurations {
-    runtimeClasspath {
-        //make sure we never package kotlin-stdlib-jdk8 or kotlin-stdlib-jdk7 because its is supplied by the IDE.
-        //see more in
-        //buildSrc/src/main/kotlin/digma-base.gradle.kts
-        //settings.gradle.kts
-        exclude("org.jetbrains.kotlin", "kotlin-stdlib-jdk8")
-        exclude("org.jetbrains.kotlin", "kotlin-stdlib-jdk7")
-    }
+configurations.getByName("runtimeClasspath") {
+    //make sure we never package kotlin-stdlib-jdk8 or kotlin-stdlib-jdk7 because its is supplied by the IDE.
+    //see more in
+    //https://plugins.jetbrains.com/docs/intellij/using-kotlin.html#kotlin-standard-library
+    //settings.gradle.kts
+    exclude("org.jetbrains.kotlin", "kotlin-stdlib")
+    exclude("org.jetbrains.kotlin", "kotlin-stdlib-jdk8")
+    exclude("org.jetbrains.kotlin", "kotlin-stdlib-jdk7")
 }
 
 
@@ -144,7 +143,7 @@ project.afterEvaluate{
 tasks {
 
     prepareSandbox{
-        //copy rider dlls to the plugin sandbox so it is packaged in the zip
+        //copy rider dlls to the plugin sandbox, so it is packaged in the zip
         from(configurations.getByName("riderDotNetObjects")){
             into("${properties("pluginName",project)}/dotnet/")
         }

ide-common/build.gradle.kts

@@ -30,6 +30,8 @@ dependencies {
     api(libs.posthog)
     api(libs.maven.artifact)
     api(libs.glovoapp.versioning)
+    api(libs.byte.buddy)
+
 
     implementation(project(":model"))
     implementation(project(":analytics-provider"))

ide-common/src/main/java/org/digma/intellij/plugin/analytics/AnalyticsService.java

@@ -444,15 +444,19 @@ public AssetNavigationResponse getAssetNavigation(@NotNull String spanCodeObject
     }
 
     public InsightsStatsResult getInsightsStats(String spanCodeObjectId) throws AnalyticsServiceException {
+
         try {
+            var env = getCurrentEnvironment();
             var params = new HashMap<String, Object>();
-            params.put("Environment",this.environment.getLatestKnownEnv());
+            params.put("Environment", env);
 
             if(spanCodeObjectId != null){
                 params.put("ScopedSpanCodeObjectId", spanCodeObjectId);
             }
 
             return executeCatching(() -> analyticsProviderProxy.getInsightsStats(params));
+        } catch (NoSelectedEnvironmentException e) {
+            Log.debugWithException(LOGGER, project, e, "error calling  insights stats", e.getMessage());
         } catch (Exception e) {
             Log.warnWithException(LOGGER, project, e, "error calling  insights stats", e.getMessage());
         }

ide-common/src/main/java/org/digma/intellij/plugin/analytics/Environment.java

@@ -45,12 +45,6 @@ public Env getCurrent() {
         return current;
     }
 
-    @Override
-    @NotNull
-    public String getLatestKnownEnv() {
-        return latestKnownEnv;
-    }
-
 
     @Override
     public void setCurrent(@NotNull Env env) {

ide-common/src/main/java/org/digma/intellij/plugin/editor/EditorEventsHandler.java

@@ -13,7 +13,6 @@
 import org.digma.intellij.plugin.log.Log;
 import org.digma.intellij.plugin.model.discovery.*;
 import org.digma.intellij.plugin.psi.*;
-import org.digma.intellij.plugin.ui.MainToolWindowCardsController;
 import org.jetbrains.annotations.NotNull;
 
 import static org.digma.intellij.plugin.common.AlarmUtilsKt.addRequestWithErrorReporting;
@@ -213,8 +212,6 @@ when editor with class A is opened and clicking another class ,say B, a caretPos
                             caretListener.maybeAddCaretListener(selectedTextEditor);
                             documentChangeListener.maybeAddDocumentListener(selectedTextEditor);
 
-                            MainToolWindowCardsController.getInstance(project).showMainPanel();
-
                             int offset = selectedTextEditor.getCaretModel().getOffset();
 
                             Backgroundable.executeOnPooledThread(() -> {

ide-common/src/main/java/org/digma/intellij/plugin/ui/MainToolWindowCardsController.java

@@ -1,6 +1,7 @@
 package org.digma.intellij.plugin.ui;
 
 import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.wm.ToolWindow;
@@ -9,6 +10,7 @@
 import org.digma.intellij.plugin.common.EDT;
 import org.digma.intellij.plugin.log.Log;
 import org.digma.intellij.plugin.ui.panels.DisposablePanel;
+import org.digma.intellij.plugin.updates.*;
 import org.jetbrains.annotations.NotNull;
 
 import javax.swing.*;
@@ -30,8 +32,10 @@ public class MainToolWindowCardsController implements Disposable {
 
     private static final Logger LOGGER = Logger.getInstance(MainToolWindowCardsController.class);
 
+
+
     public enum MainWindowCard {
-        MAIN, NO_CONNECTION
+        MAIN, NO_CONNECTION, UPDATE_MODE
     }
 
 
@@ -45,6 +49,8 @@ public enum MainWindowCard {
     //the main card panel, our main view and no-connection panel
     private JPanel cardsPanel;
 
+    //never use latestCalledCard , only in initComponents
+    private MainWindowCard latestCalledCard;
 
     //wizard content is created and disposed when necessary. WizardComponents keeps the reference to the content and the panel.
     private final WizardComponents wizard = new WizardComponents();
@@ -62,9 +68,9 @@ public enum MainWindowCard {
     public MainToolWindowCardsController(@NotNull Project project) {
         this.project = project;
 
-        project.getMessageBus()
-                .connect(this)
-                .subscribe(AnalyticsServiceConnectionEvent.ANALYTICS_SERVICE_CONNECTION_EVENT_TOPIC, new AnalyticsServiceConnectionEvent() {
+        ApplicationManager.getApplication().getMessageBus()
+                .connect()
+                .subscribe(BackendConnectionEvent.getBACKEND_CONNECTION_STATE_TOPIC(), new BackendConnectionEvent() {
                     @Override
                     public void connectionLost() {
                         Log.log(LOGGER::debug, "Got connectionLost");
@@ -80,6 +86,10 @@ public void connectionGained() {
                     }
                 });
 
+
+        ApplicationManager.getApplication().getMessageBus().connect().subscribe(AggressiveUpdateStateChangedEvent.Companion.getUPDATE_STATE_CHANGED_TOPIC(),
+                (AggressiveUpdateStateChangedEvent) this::updateStateChanged);
+
     }
 
 
@@ -125,9 +135,26 @@ public void initComponents(@NotNull ToolWindow toolWindow,
         if (isConnectionLost.get() || BackendConnectionMonitor.getInstance(project).isConnectionError()) {
             showNoConnection();
         }
+
+        //it may be that some showXXX is called before the components are initialized and
+        // cardPanel was still null. one example is showUpdateBackendPanel that may be called very early.
+        // so keep the latest called card and show it here after all components are initialized.
+        if (latestCalledCard != null) {
+            showCard(latestCalledCard);
+        }
     }
 
 
+    public void updateStateChanged(@NotNull PublicUpdateState updateState) {
+        if (updateState.getUpdateState() == CurrentUpdateState.OK) {
+            closeUpdateBackendPanel();
+        } else {
+            showUpdateBackendPanel();
+        }
+    }
+
+
+
     public void showWizard(Boolean wizardSkipInstallationStep) {
         Log.log(LOGGER::debug, "showWizard called");
 
@@ -311,7 +338,40 @@ public void showMainPanel() {
             Log.log(LOGGER::debug, "Not showing MainPanel because connection lost, showing NoConnection");
             showNoConnection();
         } else {
-            //FileEditorManager must be called on EDT
+
+            EDT.ensureEDT(() -> showCard(MainWindowCard.MAIN));
+        }
+    }
+
+    private void showUpdateBackendPanel() {
+
+        Log.log(LOGGER::debug, "showUpdateBackendPanel called");
+
+        //replace the card even if wizard is on. it will not show until wizard content is removed.
+
+        //this may happen on startup,showMainPanel is called from the tool window factory,
+        // but there may be a connection lost before the content was built and before this controller was initialized
+        if (isConnectionLost.get()) {
+            Log.log(LOGGER::debug, "Not showing MainPanel because connection lost, showing NoConnection");
+            showNoConnection();
+        } else {
+            EDT.ensureEDT(() -> showCard(MainWindowCard.UPDATE_MODE));
+        }
+    }
+
+    private void closeUpdateBackendPanel() {
+
+        Log.log(LOGGER::debug, "closeUpdateBackendPanel called");
+
+
+        //replace the card even if wizard is on. it will not show until wizard content is removed.
+
+        //this may happen on startup,showMainPanel is called from the tool window factory,
+        // but there may be a connection lost before the content was built and before this controller was initialized
+        if (isConnectionLost.get()) {
+            Log.log(LOGGER::debug, "Not showing MainPanel because connection lost, showing NoConnection");
+            showNoConnection();
+        } else {
             EDT.ensureEDT(() -> showCard(MainWindowCard.MAIN));
         }
     }
@@ -328,11 +388,25 @@ private void showNoConnection() {
 
     private void showCard(MainWindowCard card) {
         Log.log(LOGGER::debug, "showCard called with {}", card);
+
+        //need to keep the UPDATE_MODE if AggressiveUpdateService is still in update mode.
+        // after AggressiveUpdateService enters update mode there may be connection lost, the connectionLost
+        // will change to NO_CONNECTION, in that case we want to see the no connection message.
+        // on connectionGained the listener will try to change it to MAIN but if
+        // AggressiveUpdateService is still in update mode we need to replace back to UPDATE_MODE
+        MainWindowCard cardToUse;
+        if (AggressiveUpdateService.getInstance().isInUpdateMode() && card == MainWindowCard.MAIN) {
+            cardToUse = MainWindowCard.UPDATE_MODE;
+        } else {
+            cardToUse = card;
+        }
+
+        latestCalledCard = card;
         if (cardsPanel == null) {
             Log.log(LOGGER::debug, project, "show {} was called but cardsPanel is null", card);
         } else {
             Log.log(LOGGER::debug, project, "Showing card {}", card);
-            EDT.ensureEDT(() -> ((CardLayout) cardsPanel.getLayout()).show(cardsPanel, card.name()));
+            EDT.ensureEDT(() -> ((CardLayout) cardsPanel.getLayout()).show(cardsPanel, cardToUse.name()));
         }
     }
 

ide-common/src/main/kotlin/org/digma/intellij/plugin/analytics/BackendConnectionEvent.kt

@@ -0,0 +1,27 @@
+package org.digma.intellij.plugin.analytics
+
+import com.intellij.util.messages.Topic
+
+
+/**
+ * this is an application event for connection state.
+ * AnalyticsServiceConnectionEvent is a project event, but it actually should be
+ * application event because the backend is one for all projects.
+ */
+//todo: replace AnalyticsServiceConnectionEvent with this event
+interface BackendConnectionEvent {
+    companion object {
+        @JvmStatic
+        @Topic.AppLevel
+        val BACKEND_CONNECTION_STATE_TOPIC: Topic<BackendConnectionEvent> = Topic.create(
+            "BACKEND CONNECTION STATE CHANGED",
+            BackendConnectionEvent::class.java
+        )
+    }
+
+    fun connectionLost()
+
+    fun connectionGained()
+
+
+}

ide-common/src/main/kotlin/org/digma/intellij/plugin/analytics/BackendConnectionMonitor.kt

@@ -1,6 +1,7 @@
 package org.digma.intellij.plugin.analytics
 
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.project.Project
 import com.intellij.util.messages.MessageBusConnection
@@ -55,10 +56,14 @@ class BackendConnectionMonitor(val project: Project) : Disposable, AnalyticsServ
 
     override fun connectionLost() {
         connectionError()
+        //using this event as a bridge to fire BackendConnectionEvent
+        ApplicationManager.getApplication().messageBus.syncPublisher(BackendConnectionEvent.BACKEND_CONNECTION_STATE_TOPIC).connectionLost()
     }
 
     override fun connectionGained() {
         connectionOk()
+        //using this event as a bridge to fire BackendConnectionEvent
+        ApplicationManager.getApplication().messageBus.syncPublisher(BackendConnectionEvent.BACKEND_CONNECTION_STATE_TOPIC).connectionGained()
     }
 
 }

ide-common/src/main/kotlin/org/digma/intellij/plugin/common/ProjectUtils.kt

@@ -7,22 +7,22 @@ import com.intellij.openapi.wm.IdeFocusManager
 
 fun findActiveProject(): Project? {
 
-    //best effort to find a project for the notification
+    //best effort to find aa active project
 
     var project = ProjectUtil.getActiveProject()
-    if (project == null || project.isDisposed) {
+    if (project == null || !isProjectValid(project)) {
         project = IdeFocusManager.getGlobalInstance().lastFocusedFrame?.project
     }
 
-    if (project == null || project.isDisposed) {
+    if (project == null || !isProjectValid(project)) {
         project = ProjectManager.getInstance().openProjects.firstOrNull { p -> !p.isDisposed }
     }
 
-    return project
+    return project?.takeIf { isProjectValid(project) }
 
 }
 
 
 fun isProjectValid(project: Project): Boolean {
-    return !project.isDisposed && !project.isDefault
+    return !project.isDisposed && !project.isDefault && project.isOpen
 }

ide-common/src/main/kotlin/org/digma/intellij/plugin/common/VersionsUtils.kt

@@ -0,0 +1,31 @@
+package org.digma.intellij.plugin.common
+
+import com.intellij.openapi.application.ApplicationInfo
+import org.digma.intellij.plugin.model.rest.version.VersionRequest
+import org.digma.intellij.plugin.semanticversion.SemanticVersionUtil
+
+
+// returns one of:
+// IC - Intellij Community
+// RD - Rider
+fun getPlatformType(): String {
+    val appInfo = ApplicationInfo.getInstance()
+    return appInfo.build.productCode
+}
+
+fun getPlatformVersion(): String {
+    val appInfo = ApplicationInfo.getInstance()
+    return appInfo.fullVersion
+}
+
+// when plugin is not installed it will return 0.0.0
+fun getPluginVersion(defaultIfNotFound: String = "0.0.0"): String {
+    return SemanticVersionUtil.getPluginVersionWithoutBuildNumberAndPreRelease(defaultIfNotFound)
+}
+
+
+fun buildVersionRequest(): VersionRequest {
+    return VersionRequest(
+        getPluginVersion(), getPlatformType(), getPlatformVersion()
+    )
+}