Merge pull request #59 from DeepCodeAI/add_blocking_icon

Added blocking icon and fixed post-merge issues.

Author: Arvi3d

src/deepcode/DeepCodeExtension.ts

@@ -33,7 +33,7 @@ class DeepCodeExtension extends DeepCodeLib implements DeepCode.ExtensionInterfa
     try {
       await fn(...args);
     } catch (error) {
-      this.processError(error, {
+      await this.processError(error, {
         message: errorsLogs.command(name),
       });
     }
@@ -58,6 +58,7 @@ class DeepCodeExtension extends DeepCodeLib implements DeepCode.ExtensionInterfa
         DEEPCODE_OPEN_LOCAL,
         (path: vscode.Uri, range?: vscode.Range) => {
           vscode.window.showTextDocument(path, { selection: range }).then(
+            // no need to wait for processError since then is called asynchronously as well
             () => {}, (err) => this.processError(err, {
               message: errorsLogs.command(DEEPCODE_OPEN_LOCAL),
             })
@@ -102,7 +103,11 @@ class DeepCodeExtension extends DeepCodeLib implements DeepCode.ExtensionInterfa
     context.subscriptions.push(
       vscode.commands.registerCommand(
         DEEPCODE_SETMODE_COMMAND,
-        this.setMode.bind(this)
+        this.executeCommand.bind(
+          this,
+          DEEPCODE_SETMODE_COMMAND,
+          this.setMode.bind(this)
+        )
       )
     );
 
@@ -120,7 +125,11 @@ class DeepCodeExtension extends DeepCodeLib implements DeepCode.ExtensionInterfa
     context.subscriptions.push(
       vscode.commands.registerCommand(
         DEEPCODE_DCIGNORE_COMMAND,
-        createDCIgnoreCommand
+        this.executeCommand.bind(
+          this,
+          DEEPCODE_DCIGNORE_COMMAND,
+          createDCIgnoreCommand
+        )
       )
     );
 

src/deepcode/constants/general.ts

@@ -8,3 +8,5 @@ export const EXECUTION_DEBOUNCE_INTERVAL = 1000; // 1 second
 export const EXECUTION_THROTTLING_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
+// If CONNECTION_ERROR_RETRY_INTERVAL is smaller than EXECUTION_DEBOUNCE_INTERVAL it might get swallowed by the debouncer
+export const CONNECTION_ERROR_RETRY_INTERVAL = EXECUTION_DEBOUNCE_INTERVAL * 2 + 1000 * 3;

src/deepcode/constants/views.ts

@@ -1,5 +1,10 @@
-export const DEEPCODE_VIEW_SUPPORT = "deepcode.views.support";
+export const DEEPCODE_VIEW_ERROR = "deepcode.views.error";
+export const DEEPCODE_VIEW_WELCOME = "deepcode.views.welcome";
+export const DEEPCODE_VIEW_TC = "deepcode.views.tc";
+export const DEEPCODE_VIEW_EMPTY = "deepcode.views.empty";
 export const DEEPCODE_VIEW_ANALYSIS = "deepcode.views.analysis";
+export const DEEPCODE_VIEW_SUPPORT = "deepcode.views.support";
+export const DEEPCODE_VIEW_ACTIONS = "deepcode.views.actions";
 
 // Having multiple boolean contexts instead of a single context 
 // with multiple values helps us to avoid flickering UI.

src/deepcode/lib/analyzer/DeepCodeAnalyzer.ts

@@ -219,7 +219,7 @@ class DeepCodeAnalyzer implements DeepCode.AnalyzerInterface {
         this.setIssuesMarkersDecoration();
       }
     } catch (err) {
-      extension.processError(err, {
+      await extension.processError(err, {
         message: errorsLogs.updateReviewPositions,
         bundleId: (extension.remoteBundles[updatedFile.workspace] || {}).bundleId,
         data: {

src/deepcode/lib/modules/BaseDeepCodeModule.ts

@@ -8,6 +8,7 @@ import DeepCodeWorkspaceFoldersWatcher from "../watchers/WorkspaceFoldersWatcher
 import DeepCodeEditorsWatcher from "../watchers/EditorsWatcher";
 import DeepCodeSettingsWatcher from "../watchers/DeepCodeSettingsWatcher";
 import { IDE_NAME, REFRESH_VIEW_DEBOUNCE_INTERVAL } from "../../constants/general";
+import { errorsLogs } from "../../messages/errorsServerLogMessages";
 
 export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCodeModuleInterface {
   currentWorkspacePath: string;
@@ -26,6 +27,8 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
   refreshViewEmitter: vscode.EventEmitter<any>;
 	analysisStatus = '';
   analysisProgress = 0;
+  private progressBadgePromise: Promise<void> | undefined;
+  private progressBadgeResolveFn: (() => void) | undefined;
 
   // These attributes are used in tests
   staticToken = '';
@@ -89,6 +92,34 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
     return !!vscode.workspace.getConfiguration('deepcode').get<boolean>('yesTelemetry');
   }
 
+  private getProgressBadgePromise(): Promise<void> {
+    if (this.progressBadgePromise === undefined) {
+      // This should not be needed, but we resolve pending Promises 
+      // before overwriting the progressBadgeResolveFn reference.
+      if (this.progressBadgeResolveFn) this.progressBadgeResolveFn();
+      this.progressBadgePromise = new Promise(
+        (resolve) => {
+          this.progressBadgeResolveFn = resolve;
+        }
+      );
+    }
+    return this.progressBadgePromise;
+  }
+
+  // Leave viewId undefined to remove the badge from all views
+  async setLoadingBadge(viewId?: string): Promise<void> {
+    if (viewId) {
+      await vscode.window.withProgress(
+        { location: { viewId } },
+        this.getProgressBadgePromise.bind(this)
+      );
+    } else {
+      if (this.progressBadgeResolveFn) this.progressBadgeResolveFn();
+      this.progressBadgePromise = undefined;
+      this.progressBadgeResolveFn = undefined;
+    }
+  }
+
   // Avoid refreshing context/views too often:
   // https://github.com/Microsoft/vscode/issues/68424
   refreshViews = _.debounce(

src/deepcode/lib/modules/BundlesModule.ts

@@ -102,6 +102,7 @@ abstract class BundlesModule extends LoginModule
 
   onError(error: Error) {
     this.terminateAnalysis();
+    // no need to wait for processError since onError is called asynchronously as well
     this.processError(error, {
       message: errorsLogs.failedServiceAI,
     });
@@ -137,7 +138,7 @@ abstract class BundlesModule extends LoginModule
     try {
       this.serverFilesFilterList = await http.getFilters(this.baseURL, this.token);
     } catch (err) {
-      this.processError(err, {
+      await this.processError(err, {
         message: errorsLogs.filtersFiles
       })
     }
@@ -155,7 +156,7 @@ abstract class BundlesModule extends LoginModule
     if (!Object.keys(this.serverFilesFilterList).length) {
       await this.createFilesFilterList();
       if (!Object.keys(this.serverFilesFilterList).length) {
-        this.processError(new Error(errorsLogs.filtersFiles), {
+        await this.processError(new Error(errorsLogs.filtersFiles), {
           message: errorsLogs.filtersFiles,
           data: {
             filters: this.serverFilesFilterList
@@ -202,6 +203,7 @@ abstract class BundlesModule extends LoginModule
     });
 
     http.analyse(this.baseURL, this.token, path, this.files, removedFiles).catch(
+      // no need to wait for processError since catch is called asynchronously as well
       (error) => this.processError(error, {
         message: errorsLogs.analyse
       })

src/deepcode/lib/modules/DeepCodeLib.ts

@@ -44,6 +44,7 @@ export default class DeepCodeLib extends BundlesModule implements DeepCode.DeepC
   private async executeExtensionPipeline(): Promise<void> {
     console.log("DeepCode: starting execution pipeline");
     await setContext(DEEPCODE_CONTEXT.ERROR, false);
+    await this.setLoadingBadge();
 
     const loggedIn = await this.checkSession();
     if (!loggedIn) return;
@@ -70,7 +71,7 @@ export default class DeepCodeLib extends BundlesModule implements DeepCode.DeepC
       try {
         await this.executeExtensionPipeline();
       } catch (err) {
-        this.processError(err, {
+        await this.processError(err, {
           message: errorsLogs.failedExecutionDebounce,
         });
       }
@@ -79,10 +80,10 @@ export default class DeepCodeLib extends BundlesModule implements DeepCode.DeepC
     { 'leading': true }
   );
 
-  setMode(mode: string): void {
+  async setMode(mode: string): Promise<void> {
     if (!Object.values(DEEPCODE_MODE_CODES).includes(mode)) return;
     this._mode = mode;
-    setContext(DEEPCODE_CONTEXT.MODE, mode);
+    await setContext(DEEPCODE_CONTEXT.MODE, mode);
     switch(mode) {
       case DEEPCODE_MODE_CODES.PAUSED:
         this._unpauseTimeout = setTimeout(this.unpause.bind(this), EXECUTION_PAUSE_INTERVAL);

src/deepcode/lib/modules/LoginModule.ts

@@ -2,7 +2,11 @@ import ReportModule from "./ReportModule";
 import DeepCode from "../../../interfaces/DeepCodeInterfaces";
 import http from "../../http/requests";
 import { setContext, viewInBrowser } from "../../utils/vscodeCommandsUtils";
-import { DEEPCODE_CONTEXT } from "../../constants/views";
+import {
+  DEEPCODE_VIEW_WELCOME,
+  DEEPCODE_VIEW_TC,
+  DEEPCODE_CONTEXT
+} from "../../constants/views";
 import { errorsLogs } from "../../messages/errorsServerLogMessages";
 
 const sleep = (duration: number) => new Promise(resolve => setTimeout(resolve, duration));
@@ -17,7 +21,8 @@ abstract class LoginModule extends ReportModule implements DeepCode.LoginModuleI
 
     this.pendingLogin = true;
     try {
-      await setContext(DEEPCODE_CONTEXT.LOGGEDIN, false);
+      const checkCurrentToken = await this.checkSession();
+      if (checkCurrentToken) return;
       const result = await http.login(this.baseURL, this.source);
       const { sessionToken, loginURL } = result;
       if (!sessionToken || !loginURL) {
@@ -40,8 +45,9 @@ abstract class LoginModule extends ReportModule implements DeepCode.LoginModuleI
     if (this.token) {
       try {
         validSession = !!(await http.checkSession(this.baseURL, this.token));
+        if (!validSession) await this.setLoadingBadge(DEEPCODE_VIEW_WELCOME);
       } catch (err) {
-        this.processError(err, {
+        await this.processError(err, {
           message: errorsLogs.loginStatus
         });
       }
@@ -66,11 +72,13 @@ abstract class LoginModule extends ReportModule implements DeepCode.LoginModuleI
   async checkApproval(): Promise<boolean> {
     const approved = this.uploadApproved;
     await setContext(DEEPCODE_CONTEXT.APPROVED, approved);
+    if (!approved) await this.setLoadingBadge(DEEPCODE_VIEW_TC);
     return approved;
   }
 
   async approveUpload(): Promise<void> {
     await this.setUploadApproved(true);
+    await this.setLoadingBadge();
     await this.checkApproval();
   } 
 

src/deepcode/lib/modules/ReportModule.ts

@@ -4,8 +4,8 @@ import BaseDeepCodeModule from "./BaseDeepCodeModule";
 import { statusCodes } from "../../constants/statusCodes";
 import { errorsLogs } from "../../messages/errorsServerLogMessages";
 import { setContext } from "../../utils/vscodeCommandsUtils";
-import { DEEPCODE_CONTEXT, DEEPCODE_ERROR_CODES } from "../../constants/views";
-import { MAX_CONNECTION_RETRIES } from "../../constants/general";
+import { DEEPCODE_CONTEXT, DEEPCODE_ERROR_CODES, DEEPCODE_VIEW_ERROR } from "../../constants/views";
+import { MAX_CONNECTION_RETRIES, CONNECTION_ERROR_RETRY_INTERVAL } from "../../constants/general";
 
 abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.ReportModuleInterface {
   private transientErrors = 0;
@@ -45,7 +45,7 @@ abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.Repor
         ...options
       });
     } catch(error) {
-      this.processError(error, {
+      await this.processError(error, {
         message: errorsLogs.sendEvent,
         data: {
           event,
@@ -60,6 +60,17 @@ abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.Repor
   async processError(
     error: DeepCode.errorType,
     options: { [key: string]: any } = {}
+  ): Promise<void> {
+    // We don't want to have unhandled rejections around, so if it
+    // happens in the error handler we just log it to console.error
+    return this.processErrorInternal(error, options).catch((error) =>
+      console.error("DeepCode error handler failed with error:", error)
+    );
+  }
+
+  private async processErrorInternal(
+    error: DeepCode.errorType,
+    options: { [key: string]: any } = {}
   ): Promise<void> {
     console.error("DeepCode error handler:", error);
 
@@ -89,24 +100,25 @@ abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.Repor
     } = statusCodes;
 
     switch (error.statusCode) {
-      case unauthorizedContent:
-      case unauthorizedBundleAccess:
       case serverError:
       case badGateway:
       case serviceUnavailable:
       case timeout:
-        await this.connectionErrorHandler();
+        return this.connectionErrorHandler();
+      case unauthorizedContent:
+      case unauthorizedBundleAccess:
       case unauthorizedUser:
       case notFound:
       default:
         await this.sendErrorToServer(error, options);
-        await this.generalErrorHandler();
+        return this.generalErrorHandler();
     }
   }
 
   private async generalErrorHandler(): Promise<void> {
     this.transientErrors = 0;
     await setContext(DEEPCODE_CONTEXT.ERROR, DEEPCODE_ERROR_CODES.BLOCKING);
+    await this.setLoadingBadge(DEEPCODE_VIEW_ERROR);
   }
 
   private async connectionErrorHandler(): Promise<void> {
@@ -118,7 +130,7 @@ abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.Repor
       this.startExtension().catch((err) => this.processError(err, {
         message: errorsLogs.failedExecutionTransient,
       }));
-    }, 5000);
+    }, CONNECTION_ERROR_RETRY_INTERVAL);
   }
 
   private async sendErrorToServer(

src/deepcode/messages/errorsServerLogMessages.ts

@@ -26,4 +26,5 @@ export const errorsLogs = {
   command: (type: string) => `Failed to execute ${type} command`,
   sendEvent: "Failed to send event to server",
   configWatcher: "Failed to handle configuration update",
+  loadingBadge: "Failed to set loading badge icon on analysis view",
 };