more ensure active

Author: shalom938

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

@@ -8,6 +8,7 @@ import com.intellij.openapi.project.DumbService
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.project.waitForSmartMode
 import com.intellij.openapi.roots.ProjectFileIndex
+import com.intellij.openapi.vfs.AsyncFileListener
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.openapi.vfs.VirtualFileManagerListener
@@ -104,25 +105,26 @@ abstract class AbstractNavigationDiscoveryManager(protected val project: Project
             }
         })
 
-//this listener send too many events
-//        VirtualFileManager.getInstance().addAsyncFileListener({ it ->
-//            val count = it.size
-//            object : AsyncFileListener.ChangeApplier {
-//                override fun beforeVfsChange() {
-////                    if(count > 10) {
-//                    Log.trace(logger, project, "Event: beforeVfsChange, count=$count")
-//                    jonManager.stop("stop because beforeVfsChange")
-////                    }
-//                }
-//
-//                override fun afterVfsChange() {
-////                    if (count > 10) {
-//                    Log.trace(logger, project, "Event: afterVfsChange, count=$count")
-//                    jonManager.startWithDelay()
-////                    }
-//                }
-//            }
-//        }, this)
+        VirtualFileManager.getInstance().addAsyncFileListener({ it ->
+            val minSizeToActivate = 50
+            val count = it.size
+            object : AsyncFileListener.ChangeApplier {
+                private val isInBulkUpdate = AtomicBoolean(false)
+                override fun beforeVfsChange() {
+                    if (isInBulkUpdate.compareAndSet(false, true) && count > minSizeToActivate) {
+                        Log.trace(logger, project, "Event: beforeVfsChange, count=$count")
+                        jonManager.stop("stop because beforeVfsChange")
+                    }
+                }
+
+                override fun afterVfsChange() {
+                    if (isInBulkUpdate.compareAndSet(true, false) && count > minSizeToActivate) {
+                        Log.trace(logger, project, "Event: afterVfsChange, count=$count")
+                        jonManager.startWithDelay()
+                    }
+                }
+            }
+        }, this)
 
 
         VirtualFileManager.getInstance().addVirtualFileManagerListener(object : VirtualFileManagerListener {
@@ -169,7 +171,7 @@ abstract class AbstractNavigationDiscoveryManager(protected val project: Project
         private var stuckTimerJob: Job? = null
 
         init {
-            managementJob = cs.launchWithErrorReporting("${this::class.java.simpleName}.JobManager", logger){
+            managementJob = cs.launchWithErrorReporting("${this::class.java.simpleName}.JobManager", logger) {
                 Log.trace(logger, project, "JobManager: managementJob started")
                 jobManagementChannel.consumeEach { command: JobCommand ->
                     Log.trace(logger, project, "JobManager: processing command: {}", command::class.java.simpleName)
@@ -208,7 +210,7 @@ abstract class AbstractNavigationDiscoveryManager(protected val project: Project
         // is not 0, then restart the jobs and hope for the best.
         private fun startStuckTimer() {
             stuckTimerJob?.cancel()
-            stuckTimerJob = cs.launchWithErrorReporting("$ {this::class.java.simpleName}.JobManager.startStuckTimer", logger){
+            stuckTimerJob = cs.launchWithErrorReporting("$ {this::class.java.simpleName}.JobManager.startStuckTimer", logger) {
                 delay(5.minutes)
                 @Suppress("UnstableApiUsage")
                 project.waitForSmartMode()
@@ -227,7 +229,7 @@ abstract class AbstractNavigationDiscoveryManager(protected val project: Project
         }
 
         fun startup() {
-            cs.launchWithErrorReporting("${this::class.java.simpleName}.JobManager.startup", logger){
+            cs.launchWithErrorReporting("${this::class.java.simpleName}.JobManager.startup", logger) {
                 //on startup currentState is not relevant, if its 0 the jobs will start, if it was changed by any listener,
                 // the jobs will not start until the currentState is 0 again when a listener calls startWithDelay
                 Log.trace(logger, project, "JobManager: startup called, sending RestartWithDelay command")
@@ -256,7 +258,10 @@ abstract class AbstractNavigationDiscoveryManager(protected val project: Project
                 } else {
                     Log.warn(logger, project, "JobManager: RestartWithDelay command failed with ${result.exceptionOrNull()}")
                     ErrorReporter.getInstance()
-                        .reportError("AbstractNavigationDiscoveryManager.JobManager.startWithDelay", result.exceptionOrNull() ?: Exception("Unknown error"))
+                        .reportError(
+                            "AbstractNavigationDiscoveryManager.JobManager.startWithDelay",
+                            result.exceptionOrNull() ?: Exception("Unknown error")
+                        )
                 }
             }
         }

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

@@ -102,7 +102,6 @@ fun <T> CoroutineScope.asyncWithErrorReporting(
     } catch (e: Throwable) {
         Log.warnWithException(logger, e, "Error in coroutine {}", e)
         ErrorReporter.getInstance().reportError("asyncWithErrorReporting.$name", e)
-        //todo: will jetbrains consider it as unhandled exception? if yes swallow the exceptions and return empty Deferred
         throw e
     }
 }

jvm-common/src/main/kotlin/org/digma/intellij/plugin/idea/discovery/AbstractCodeObjectDiscovery.kt

@@ -96,9 +96,7 @@ abstract class AbstractCodeObjectDiscovery(private val spanDiscovery: AbstractSp
             }
 
             //maybe uFile is null,there is nothing to do without a UFile.
-            val fileData = readAction {
-                FileData.buildFileData(psiFile)
-            } ?: return null
+            val fileData = FileData.buildFileData(psiFile) ?: return null
             coroutineContext.ensureActive()
 
             val packageName = fileData.packageName
@@ -208,10 +206,12 @@ abstract class AbstractCodeObjectDiscovery(private val spanDiscovery: AbstractSp
 
 private class FileData(val uFile: UFile, val packageName: String) {
     companion object {
-        fun buildFileData(psiFile: PsiFile): FileData? {
-            val uFile: UFile? = psiFile.toUElementOfType<UFile>()
-            return uFile?.let {
-                val packageName = it.packageName
+        suspend fun buildFileData(psiFile: PsiFile): FileData? {
+            coroutineContext.ensureActive()
+            val uFile: UFile? = readAction { psiFile.takeIf { it.isValid }?.toUElementOfType<UFile>() }
+            return uFile?.takeIf { it.isPsiValid }?.let {
+                coroutineContext.ensureActive()
+                val packageName = readAction { it.packageName }
                 FileData(it, packageName)
             }
         }

jvm-common/src/main/kotlin/org/digma/intellij/plugin/idea/discovery/span/AbstractSpanDiscovery.kt

@@ -1,5 +1,6 @@
 package org.digma.intellij.plugin.idea.discovery.span
 
+import com.intellij.openapi.application.readAction
 import com.intellij.openapi.application.smartReadAction
 import com.intellij.openapi.components.service
 import com.intellij.openapi.diagnostic.Logger
@@ -159,10 +160,16 @@ abstract class AbstractSpanDiscovery {
         searchScope: SearchScopeProvider,
     ): Collection<UReferenceExpression>? {
 
-        return smartReadAction(project) {
+        coroutineContext.ensureActive()
+        val methodReferences = smartReadAction(project) {
             startSpanMethodPointer.element?.let { startSpanMethod ->
-                val methodReferences = MethodReferencesSearch.search(startSpanMethod, searchScope.get(), true)
-                methodReferences.findAll().mapNotNull { psiReference: PsiReference -> psiReference.element.toUElementOfType<UReferenceExpression>() }
+                MethodReferencesSearch.search(startSpanMethod, searchScope.get(), true)
+            }
+        }
+        coroutineContext.ensureActive()
+        return methodReferences?.let {
+            readAction {
+                it.findAll().mapNotNull { psiReference: PsiReference -> psiReference.element.toUElementOfType<UReferenceExpression>() }
             }
         }
     }