bugfix: Fix the bug that the explorer will be out-of-sync occasionally (#340)

Author: jdneo

src/syncHandler.ts

@@ -87,7 +87,7 @@ class SyncHandler implements Disposable {
             } else {
                 // the direct parent is not rendered in the explorer, the returned node
                 // is other package fragment, we need to refresh the package fragment root.
-                while (node && node.nodeData.kind !== NodeKind.PackageRoot) {
+                while (node && node.nodeData.kind > NodeKind.PackageRoot) {
                     node = <DataNode>node.getParent();
                 }
                 return node;

src/utils/Lock.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import { EventEmitter } from "events";
+
+export class Lock {
+    private _locked: boolean;
+    private _eventEmitter: EventEmitter;
+
+    constructor() {
+        this._locked = false;
+        this._eventEmitter = new EventEmitter();
+    }
+
+    public async acquire(): Promise<void> {
+        return new Promise((resolve) => {
+            if (!this._locked) {
+                this._locked = true;
+                return resolve();
+            }
+
+            const tryAcquire = () => {
+                if (!this._locked) {
+                    this._locked = true;
+                    this._eventEmitter.removeListener("release", tryAcquire);
+                    return resolve();
+                }
+            };
+            this._eventEmitter.on("release", tryAcquire);
+        });
+    }
+
+    public release(): void {
+        this._locked = false;
+        setImmediate(() => this._eventEmitter.emit("release"));
+    }
+}

src/views/dataNode.ts

@@ -2,11 +2,15 @@
 // Licensed under the MIT license.
 
 import * as _ from "lodash";
-import { ProviderResult, ThemeIcon, TreeItem, TreeItemCollapsibleState, Uri } from "vscode";
+import { ThemeIcon, TreeItem, TreeItemCollapsibleState, Uri } from "vscode";
 import { INodeData } from "../java/nodeData";
+import { Lock } from "../utils/Lock";
 import { ExplorerNode } from "./explorerNode";
 
 export abstract class DataNode extends ExplorerNode {
+
+    protected _lock: Lock = new Lock();
+
     constructor(protected _nodeData: INodeData, parent: DataNode) {
         super(parent);
     }
@@ -56,14 +60,18 @@ export abstract class DataNode extends ExplorerNode {
         return (childNode && paths.length) ? childNode.revealPaths(paths) : childNode;
     }
 
-    public getChildren(): ProviderResult<ExplorerNode[]> {
-        if (!this._nodeData.children) {
-            return this.loadData().then((res) => {
-                this._nodeData.children = res;
+    public async getChildren(): Promise<ExplorerNode[]> {
+        try {
+            await this._lock.acquire();
+            if (!this._nodeData.children) {
+                const data = await this.loadData();
+                this._nodeData.children = data;
                 return this.createChildNodeList();
-            });
+            }
+            return this.createChildNodeList();
+        } finally {
+            this._lock.release();
         }
-        return this.createChildNodeList();
     }
 
     protected computeContextValue(): string {

src/views/dependencyDataProvider.ts

@@ -14,6 +14,7 @@ import { isLightWeightMode, isSwitchingServer } from "../extension";
 import { Jdtls } from "../java/jdtls";
 import { INodeData, NodeKind } from "../java/nodeData";
 import { Settings } from "../settings";
+import { Lock } from "../utils/Lock";
 import { DataNode } from "./dataNode";
 import { ExplorerNode } from "./explorerNode";
 import { explorerNodeCache } from "./nodeCache/explorerNodeCache";
@@ -24,6 +25,8 @@ export class DependencyDataProvider implements TreeDataProvider<ExplorerNode> {
 
     private _onDidChangeTreeData: EventEmitter<ExplorerNode | null | undefined> = new EventEmitter<ExplorerNode | null | undefined>();
 
+    private _lock: Lock = new Lock();
+
     // tslint:disable-next-line:member-ordering
     public onDidChangeTreeData: Event<ExplorerNode | null | undefined> = this._onDidChangeTreeData.event;
 
@@ -125,7 +128,7 @@ export class DependencyDataProvider implements TreeDataProvider<ExplorerNode> {
     }
 
     private async getRootProjects(): Promise<ExplorerNode[]> {
-        const rootElements = this._rootItems ? this._rootItems : await this.getChildren();
+        const rootElements = await this.getRootNodes();
         if (rootElements[0] instanceof ProjectNode) {
             return rootElements;
         } else {
@@ -138,9 +141,15 @@ export class DependencyDataProvider implements TreeDataProvider<ExplorerNode> {
         }
     }
 
-    private getRootNodes(): Thenable<ExplorerNode[]> {
-        return new Promise((resolve, reject) => {
-            const rootItems = new Array<ExplorerNode>();
+    private async getRootNodes(): Promise<ExplorerNode[]> {
+        try {
+            await this._lock.acquire();
+
+            if (this._rootItems) {
+                return this._rootItems;
+            }
+
+            const rootItems: ExplorerNode[] = [];
             const folders = workspace.workspaceFolders;
             if (folders && folders.length) {
                 if (folders.length > 1) {
@@ -150,19 +159,20 @@ export class DependencyDataProvider implements TreeDataProvider<ExplorerNode> {
                         kind: NodeKind.Workspace,
                     }, null)));
                     this._rootItems = rootItems;
-                    resolve(rootItems);
+                    return rootItems;
                 } else {
-                    Jdtls.getProjects(folders[0].uri.toString()).then((result: INodeData[]) => {
-                        result.forEach((project) => {
-                            rootItems.push(new ProjectNode(project, null));
-                        });
-                        this._rootItems = rootItems;
-                        resolve(rootItems);
+                    const result: INodeData[] = await Jdtls.getProjects(folders[0].uri.toString());
+                    result.forEach((project) => {
+                        rootItems.push(new ProjectNode(project, null));
                     });
+                    this._rootItems = rootItems;
+                    return rootItems;
                 }
             } else {
-                reject("No workspace found");
+                throw new Error("No workspace folder found, please open a folder into the workspace first.");
             }
-        });
+        } finally {
+            this._lock.release();
+        }
     }
 }

src/views/hierarchicalPackageNode.ts

@@ -25,17 +25,21 @@ export class HierarchicalPackageNode extends PackageNode {
         }
     }
 
-    public getChildren(): ProviderResult<ExplorerNode[]> {
-        return this.loadData().then((res) => {
-            if (res) {
+    public async getChildren(): Promise<ExplorerNode[]> {
+        try {
+            await this._lock.acquire();
+            const data = await this.loadData();
+            if (data) {
                 if (this.nodeData?.children) {
-                    this.nodeData.children.push(...res);
+                    this.nodeData.children.push(...data);
                 } else {
-                    this.nodeData.children = res;
+                    this.nodeData.children = data;
                 }
             }
             return this.createChildNodeList();
-        });
+        } finally {
+            this._lock.release();
+        }
     }
 
     public async revealPaths(paths: INodeData[]): Promise<DataNode> {