feat: refresh remote tree on sketch create

Signed-off-by: Akos Kitta <[email protected]>

Author: Akos Kitta

arduino-ide-extension/src/browser/contributions/new-cloud-sketch.ts

@@ -110,7 +110,6 @@ export class NewCloudSketch extends Contribution {
       }
     } finally {
       if (result) {
-        await treeModel.updateRoot();
         await treeModel.refresh();
       }
     }
@@ -145,7 +144,6 @@ export class NewCloudSketch extends Contribution {
       await treeModel.sketchbookTree().pull({ node });
     } catch (err) {
       if (isNotFound(err)) {
-        await treeModel.updateRoot();
         await treeModel.refresh();
         this.messageService.error(
           nls.localize(

arduino-ide-extension/src/browser/local-cache/local-cache-fs-provider.ts

@@ -34,7 +34,6 @@ export class LocalCacheFsProvider
   @inject(AuthenticationClientService)
   protected readonly authenticationService: AuthenticationClientService;
 
-  // TODO: do we need this? Cannot we `await` on the `init` call from `registerFileSystemProviders`?
   readonly ready = new Deferred<void>();
 
   private _localCacheRoot: URI;
@@ -153,7 +152,7 @@ export class LocalCacheFsProvider
     return uri;
   }
 
-  private toUri(session: AuthenticationSession): URI {
+  toUri(session: AuthenticationSession): URI {
     // Hack: instead of getting the UUID only, we get `auth0|UUID` after the authentication. `|` cannot be part of filesystem path or filename.
     return this._localCacheRoot.resolve(session.id.split('|')[1]);
   }

arduino-ide-extension/src/browser/widgets/cloud-sketchbook/cloud-sketchbook-tree-model.ts

@@ -1,20 +1,31 @@
-import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { TreeNode } from '@theia/core/lib/browser/tree';
+import {
+  inject,
+  injectable,
+  postConstruct,
+} from '@theia/core/shared/inversify';
+import { CompositeTreeNode, TreeNode } from '@theia/core/lib/browser/tree';
 import { posixSegments, splitSketchPath } from '../../create/create-paths';
 import { CreateApi } from '../../create/create-api';
 import { CloudSketchbookTree } from './cloud-sketchbook-tree';
 import { AuthenticationClientService } from '../../auth/authentication-client-service';
 import { SketchbookTreeModel } from '../sketchbook/sketchbook-tree-model';
-import { ArduinoPreferences } from '../../arduino-preferences';
 import { WorkspaceNode } from '@theia/navigator/lib/browser/navigator-tree';
 import { CreateUri } from '../../create/create-uri';
-import { FileStat } from '@theia/filesystem/lib/common/files';
-import { LocalCacheFsProvider } from '../../local-cache/local-cache-fs-provider';
-import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import {
+  FileChangesEvent,
+  FileChangeType,
+  FileStat,
+} from '@theia/filesystem/lib/common/files';
+import {
+  LocalCacheFsProvider,
+  LocalCacheUri,
+} from '../../local-cache/local-cache-fs-provider';
 import URI from '@theia/core/lib/common/uri';
 import { SketchCache } from './cloud-sketch-cache';
 import { Create } from '../../create/typings';
-import { nls } from '@theia/core/lib/common';
+import { nls } from '@theia/core/lib/common/nls';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export function sketchBaseDir(sketch: Create.Sketch): FileStat {
   // extract the sketch path
@@ -52,35 +63,79 @@ export function sketchesToFileStats(sketches: Create.Sketch[]): FileStat[] {
 
 @injectable()
 export class CloudSketchbookTreeModel extends SketchbookTreeModel {
-  @inject(FileService)
-  protected override readonly fileService: FileService;
-
-  @inject(AuthenticationClientService)
-  protected readonly authenticationService: AuthenticationClientService;
-
   @inject(CreateApi)
-  protected readonly createApi: CreateApi;
-
-  @inject(CloudSketchbookTree)
-  protected readonly cloudSketchbookTree: CloudSketchbookTree;
-
-  @inject(ArduinoPreferences)
-  protected override readonly arduinoPreferences: ArduinoPreferences;
-
+  private readonly createApi: CreateApi;
+  @inject(AuthenticationClientService)
+  private readonly authenticationService: AuthenticationClientService;
   @inject(LocalCacheFsProvider)
-  protected readonly localCacheFsProvider: LocalCacheFsProvider;
-
+  private readonly localCacheFsProvider: LocalCacheFsProvider;
   @inject(SketchCache)
-  protected readonly sketchCache: SketchCache;
+  private readonly sketchCache: SketchCache;
+
+  private readonly toDisposeOnSessionDidChange = new DisposableCollection();
+  private _localCacheFsProviderReady: Deferred<void> | undefined;
 
   @postConstruct()
   protected override init(): void {
     super.init();
     this.toDispose.push(
-      this.authenticationService.onSessionDidChange(() => this.updateRoot())
+      this.authenticationService.onSessionDidChange((session) => {
+        this.updateRoot();
+        this.toDisposeOnSessionDidChange.dispose();
+        if (session) {
+          this.toDisposeOnSessionDidChange.push(
+            this.fileService.watch(CreateUri.root)
+          );
+        }
+      })
+    );
+    this.ensureLocalFsProviderReady();
+  }
+
+  override *getNodesByUri(uri: URI): IterableIterator<TreeNode> {
+    if (uri.scheme === LocalCacheUri.scheme) {
+      const workspace = this.root;
+      const { session } = this.authenticationService;
+      if (session && WorkspaceNode.is(workspace)) {
+        const currentUri = this.localCacheFsProvider.to(uri);
+        if (currentUri) {
+          const rootPath = this.localCacheFsProvider
+            .toUri(session)
+            .path.toString();
+          const currentPath = currentUri.path.toString();
+          if (rootPath === currentPath) {
+            return workspace;
+          }
+          if (currentPath.startsWith(rootPath)) {
+            const id = currentPath.substring(rootPath.length);
+            const node = this.getNode(id);
+            if (node) {
+              yield node;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  protected override isRootAffected(changes: FileChangesEvent): boolean {
+    return changes.changes.some(
+      (change) =>
+        change.type === FileChangeType.ADDED &&
+        change.resource.parent.toString() === LocalCacheUri.root.toString()
     );
   }
 
+  override async refresh(
+    parent?: Readonly<CompositeTreeNode>
+  ): Promise<CompositeTreeNode | undefined> {
+    if (parent) {
+      return super.refresh(parent);
+    }
+    await this.updateRoot();
+    return super.refresh();
+  }
+
   override async createRoot(): Promise<TreeNode | undefined> {
     const { session } = this.authenticationService;
     if (!session) {
@@ -89,7 +144,10 @@ export class CloudSketchbookTreeModel extends SketchbookTreeModel {
     }
     this.createApi.init(this.authenticationService, this.arduinoPreferences);
     this.sketchCache.init();
-    const sketches = await this.createApi.sketches();
+    const [sketches] = await Promise.all([
+      this.createApi.sketches(),
+      this.ensureLocalFsProviderReady(),
+    ]);
     const rootFileStats = sketchesToFileStats(sketches);
     if (this.workspaceService.opened) {
       const workspaceNode = WorkspaceNode.createRoot(
@@ -108,7 +166,9 @@ export class CloudSketchbookTreeModel extends SketchbookTreeModel {
     return this.tree as CloudSketchbookTree;
   }
 
-  protected override recursivelyFindSketchRoot(node: TreeNode): any {
+  protected override recursivelyFindSketchRoot(
+    node: TreeNode
+  ): TreeNode | false {
     if (node && CloudSketchbookTree.CloudSketchDirNode.is(node)) {
       return node;
     }
@@ -132,4 +192,15 @@ export class CloudSketchbookTreeModel extends SketchbookTreeModel {
       return super.revealFile(uri);
     }
   }
+
+  private async ensureLocalFsProviderReady(): Promise<void> {
+    if (this._localCacheFsProviderReady) {
+      return this._localCacheFsProviderReady.promise;
+    }
+    this._localCacheFsProviderReady = new Deferred();
+    this.fileService
+      .access(LocalCacheUri.root)
+      .then(() => this._localCacheFsProviderReady?.resolve());
+    return this._localCacheFsProviderReady.promise;
+  }
 }

arduino-ide-extension/src/browser/widgets/cloud-sketchbook/cloud-sketchbook-tree.ts

@@ -269,7 +269,7 @@ export class CloudSketchbookTree extends SketchbookTree {
         return prev;
       }
 
-      // do not map "do_not_sync" files/directoris and their descendants
+      // do not map "do_not_sync" files/directories and their descendants
       const segments = path[1].split(posix.sep) || [];
       if (
         segments.some((segment) => Create.do_not_sync_files.includes(segment))