Fixed manual analysis now overriding throttling

Author: shinin-light

package.json

@@ -167,7 +167,7 @@
       },
       {
         "view": "deepcode.views.actions",
-        "contents": "You are currently running DeepCode in throttled mode. It scans your code every 30 minutes if it detects changes in your files.\n[Auto](command:deepcode.setmode?%5B%22auto%22%5D)",
+        "contents": "You are currently running DeepCode in throttled mode. It scans your code every 30 minutes if it detects changes in your files.\n[Analyze now](command:deepcode.start)\n[Switch to auto-scan mode](command:deepcode.setmode?%5B%22auto%22%5D)",
         "when": "deepcode:mode == 'throttled'"
       },
       {

src/deepcode/constants/general.ts

@@ -5,6 +5,6 @@ export const ALLOWED_PAYLOAD_SIZE = 1024 * 1024 * 4; // max payload size of 4MB
 export const MAX_CONNECTION_RETRIES = 5; // max number of automatic retries before showing an error
 export const IDE_NAME = "vscode";
 export const EXECUTION_DEBOUNCE_INTERVAL = 1000; // 1 second
-export const EXECUTION_DEBOUNCE_EXTENDED_INTERVAL = 1000 * 60 * 30; // 30 minutes
+export const EXECUTION_DEBOUNCE_EXTENDED_INTERVAL = 1000 * 10;// * 60 * 30; // 30 minutes
 export const EXECUTION_PAUSE_INTERVAL = 1000 * 60 * 30; // 30 minutes
 export const REFRESH_VIEW_DEBOUNCE_INTERVAL = 200; // 200 milliseconds

src/deepcode/lib/modules/DeepCodeLib.ts

@@ -13,8 +13,22 @@ export default class DeepCodeLib extends BundlesModule implements DeepCode.DeepC
   private _mode = DEEPCODE_MODE_CODES.AUTO;
   // Platform-independant type definition.
   private _unpauseTimeout: ReturnType<typeof setTimeout> | undefined;
+  private _lastExecution: number | undefined;
 
-  private unpause() {
+  private shouldBeThrottled(): boolean {
+    if (this._mode !== DEEPCODE_MODE_CODES.THROTTLED) return false;
+    const now = Date.now();
+    if (
+      this._lastExecution === undefined || 
+      (now - this._lastExecution) >= EXECUTION_DEBOUNCE_EXTENDED_INTERVAL
+    ) {
+      this._lastExecution = now;
+      return false;
+    }
+    return true;
+  }
+  
+  private unpause(): void {
     if (this._mode === DEEPCODE_MODE_CODES.PAUSED) this.setMode(DEEPCODE_MODE_CODES.AUTO);
   }
 
@@ -39,28 +53,28 @@ export default class DeepCodeLib extends BundlesModule implements DeepCode.DeepC
     this.resetTransientErrors();
   }
 
-  private getDebouncedExecution(wait: number) {
-    return _.debounce(
-      async (manual = false): Promise<void> => {
-        // If the execution is suspended, we only allow user-triggered analyses.
-        if (!manual && [
-          DEEPCODE_MODE_CODES.MANUAL,
-          DEEPCODE_MODE_CODES.PAUSED
-        ].includes(this._mode)) return;
-        // This function is called by commands, error handlers, etc.
-        // We should avoid having duplicate parallel executions.
-        try {
-          await this.executeExtensionPipeline();
-        } catch (err) {
-          this.processError(err);
-        }
-      },
-      wait,
-      { 'leading': true }
-    );
-  }
-
-  startExtension = this.getDebouncedExecution(EXECUTION_DEBOUNCE_INTERVAL);
+  // This function is called by commands, error handlers, etc.
+  // We should avoid having duplicate parallel executions.
+  startExtension = _.debounce(
+    async (manual = false): Promise<void> => {
+      // If the execution is suspended, we only allow user-triggered analyses.
+      if (!manual) {
+        if ([
+            DEEPCODE_MODE_CODES.MANUAL,
+            DEEPCODE_MODE_CODES.PAUSED
+          ].includes(this._mode) || 
+          this.shouldBeThrottled()
+        ) return;
+      }
+      try {
+        await this.executeExtensionPipeline();
+      } catch (err) {
+        this.processError(err);
+      }
+    },
+    EXECUTION_DEBOUNCE_INTERVAL,
+    { 'leading': true }
+  );
 
   setMode(mode: string): void {
     if (!Object.values(DEEPCODE_MODE_CODES).includes(mode)) return;
@@ -69,16 +83,11 @@ export default class DeepCodeLib extends BundlesModule implements DeepCode.DeepC
     switch(mode) {
       case DEEPCODE_MODE_CODES.PAUSED:
         this._unpauseTimeout = setTimeout(this.unpause.bind(this), EXECUTION_PAUSE_INTERVAL);
-        this.startExtension = this.getDebouncedExecution(EXECUTION_DEBOUNCE_INTERVAL);
         break;
       case DEEPCODE_MODE_CODES.AUTO:
       case DEEPCODE_MODE_CODES.MANUAL:
-        if (this._unpauseTimeout) clearTimeout(this._unpauseTimeout);
-        this.startExtension = this.getDebouncedExecution(EXECUTION_DEBOUNCE_INTERVAL);
-        break;
       case DEEPCODE_MODE_CODES.THROTTLED:
         if (this._unpauseTimeout) clearTimeout(this._unpauseTimeout);
-        this.startExtension = this.getDebouncedExecution(EXECUTION_DEBOUNCE_EXTENDED_INTERVAL);
         break;
     }
   }