notify client after client re-initialization.

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

Author: Akos Kitta

arduino-ide-extension/src/node/core-client-provider.ts

@@ -93,10 +93,6 @@ export class CoreClientProvider {
    */
   private async create(port: string): Promise<CoreClientProvider.Client> {
     this.closeClient();
-    // Normal startup workflow:
-    // 1. create instance,
-    // 2. init instance,
-    // 3. update indexes asynchronously.
     const address = this.address(port);
     const client = await this.createClient(address);
     this.toDisposeBeforeCreate.pushAll([
@@ -110,33 +106,46 @@ export class CoreClientProvider {
         this.ready = new Deferred();
       }),
     ]);
+    await this.initInstanceWithFallback(client);
+    setTimeout(async () => this.refreshIndexes(), 10_000); // Update the indexes asynchronously
+    return this.useClient(client);
+  }
+
+  /**
+   * By default, calling this method is equivalent to the `initInstance(Client)` call.
+   * When the IDE2 starts and one of the followings is missing,
+   * the IDE2 must run the index update before the core client initialization:
+   *
+   *  - primary package index (`#directories.data/package_index.json`),
+   *  - library index (`#directories.data/library_index.json`),
+   *  - built-in tools (`builtin:serial-discovery` or `builtin:mdns-discovery`)
+   *
+   * This method detects such errors and runs an index update before initializing the client.
+   * The index update will fail if the 3rd URLs list contains an invalid URL,
+   * and the IDE2 will be [non-functional](https://github.com/arduino/arduino-ide/issues/1084). Since the CLI [cannot update only the primary package index]((https://github.com/arduino/arduino-cli/issues/1788)), IDE2 does its dirty solution.
+   */
+  private async initInstanceWithFallback(
+    client: CoreClientProvider.Client
+  ): Promise<void> {
     try {
-      await this.initInstance(client); // init the gRPC core client instance
-      setTimeout(async () => this.refreshIndexes(), 10_000); // Update the indexes asynchronously
-      return this.useClient(client);
-    } catch (error) {
-      if (error instanceof IndexUpdateRequiredBeforeInitError) {
+      await this.initInstance(client);
+    } catch (err) {
+      if (err instanceof IndexUpdateRequiredBeforeInitError) {
         console.error(
           'The primary packages indexes are missing. Running indexes update before initializing the core gRPC client',
-          error.message
+          err.message
         );
-        // If it's a first start, IDE2 must run index update before the init request.
-        // First startup workflow:
-        // 1. create instance,
-        // 2. update indexes and wait (to download the built-in pluggable tools, etc),
-        // 3. init instance.
-        await this.updateIndexes(client);
+        await this.updateIndexes(client); // TODO: this should run without the 3rd party URLs
         await this.initInstance(client);
         console.info(
           `Downloaded the primary packages indexes, and successfully initialized the core gRPC client.`
         );
-        return this.useClient(client);
       } else {
         console.error(
           'Error occurred while initializing the core gRPC client provider',
-          error
+          err
         );
-        throw error;
+        throw err;
       }
     }
   }
@@ -195,44 +204,31 @@ export class CoreClientProvider {
     client,
     instance,
   }: CoreClientProvider.Client): Promise<void> {
-    const initReq = new InitRequest();
-    initReq.setInstance(instance);
     return new Promise<void>((resolve, reject) => {
-      const stream = client.init(initReq);
       const errors: RpcStatus[] = [];
-      stream.on('data', (res: InitResponse) => {
-        const progress = res.getInitProgress();
-        if (progress) {
-          const downloadProgress = progress.getDownloadProgress();
-          if (downloadProgress && downloadProgress.getCompleted()) {
-            const file = downloadProgress.getFile();
-            console.log(`Downloaded ${file}`);
+      client
+        .init(new InitRequest().setInstance(instance))
+        .on('data', (resp: InitResponse) => {
+          // The CLI never sends `initProgress`, it's always `error` or nothing. Is this a CLI bug?
+          // According to the gRPC API, the CLI should send either a `TaskProgress` or a `DownloadProgress`, but it does not.
+          const error = resp.getError();
+          if (error) {
+            const { code, message } = Status.toObject(false, error);
+            console.error(
+              `Detected an error response during the gRPC core client initialization: code: ${code}, message: ${message}`
+            );
+            errors.push(error);
           }
-          const taskProgress = progress.getTaskProgress();
-          if (taskProgress && taskProgress.getCompleted()) {
-            const name = taskProgress.getName();
-            console.log(`Completed ${name}`);
+        })
+        .on('error', reject)
+        .on('end', () => {
+          const error = this.evaluateErrorStatus(errors);
+          if (error) {
+            reject(error);
+            return;
           }
-        }
-
-        const error = res.getError();
-        if (error) {
-          const { code, message } = Status.toObject(false, error);
-          console.error(
-            `Detected an error response during the gRPC core client initialization: code: ${code}, message: ${message}`
-          );
-          errors.push(error);
-        }
-      });
-      stream.on('error', reject);
-      stream.on('end', () => {
-        const error = this.evaluateErrorStatus(errors);
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
+          resolve();
+        });
     });
   }
 
@@ -251,32 +247,34 @@ export class CoreClientProvider {
   private async refreshIndexes(): Promise<void> {
     const client = this._client;
     if (client) {
-      await this.updateIndexes(client);
-      await this.initInstance(client);
+      const progressHandler = this.createProgressHandler();
+      try {
+        await this.updateIndexes(client, progressHandler);
+        await this.initInstance(client);
+        // notify clients about the index update only after the client has been "re-initialized" and the new content is available.
+        progressHandler.reportEnd();
+      } catch (err) {
+        console.error('Failed to update indexes', err);
+        progressHandler.reportError(
+          ServiceError.is(err) ? err.details : String(err)
+        );
+      }
     }
   }
 
   private async updateIndexes(
-    client: CoreClientProvider.Client
+    client: CoreClientProvider.Client,
+    progressHandler?: IndexesUpdateProgressHandler
   ): Promise<void> {
-    const progressHandler = this.createProgressHandler();
-    try {
-      await Promise.all([
-        this.updateIndex(client, progressHandler),
-        this.updateLibraryIndex(client, progressHandler),
-      ]);
-      progressHandler.reportEnd();
-    } catch (err) {
-      console.error('Failed to update indexes', err);
-      progressHandler.reportError(
-        ServiceError.is(err) ? err.details : String(err)
-      );
-    }
+    await Promise.all([
+      this.updateIndex(client, progressHandler),
+      this.updateLibraryIndex(client, progressHandler),
+    ]);
   }
 
   private async updateIndex(
     client: CoreClientProvider.Client,
-    progressHandler: IndexesUpdateProgressHandler
+    progressHandler?: IndexesUpdateProgressHandler
   ): Promise<void> {
     return this.doUpdateIndex(
       () =>
@@ -290,7 +288,7 @@ export class CoreClientProvider {
 
   private async updateLibraryIndex(
     client: CoreClientProvider.Client,
-    progressHandler: IndexesUpdateProgressHandler
+    progressHandler?: IndexesUpdateProgressHandler
   ): Promise<void> {
     return this.doUpdateIndex(
       () =>
@@ -309,10 +307,10 @@ export class CoreClientProvider {
       | UpdateCoreLibrariesIndexResponse // not used by IDE2
   >(
     responseProvider: () => grpc.ClientReadableStream<R>,
-    progressHandler: IndexesUpdateProgressHandler,
+    progressHandler?: IndexesUpdateProgressHandler,
     task?: string
   ): Promise<void> {
-    const { progressId } = progressHandler;
+    const progressId = progressHandler?.progressId;
     return retry(
       () =>
         new Promise<void>((resolve, reject) => {
@@ -326,7 +324,7 @@ export class CoreClientProvider {
                       `core-client-provider${task ? ` [${task}]` : ''}`,
                       message
                     );
-                    progressHandler.reportProgress(message);
+                    progressHandler?.reportProgress(message);
                   },
                 },
                 progressId,

arduino-ide-extension/src/node/grpc-progressible.ts

@@ -272,7 +272,7 @@ export class IndexesUpdateProgressHandler {
     const totalPlatformIndexCount = additionalUrlsCount + 1;
     // The `library_index.json.gz` and `library_index.json.sig` when running the library index update.
     const totalLibraryIndexCount = 2;
-    // +1 for better UX (`reportEnd`)
+    // +1 for the `initInstance` call after the index update (`reportEnd`)
     return totalPlatformIndexCount + totalLibraryIndexCount + 1;
   }
 }