Merge branch 'main' into 1032-uploads-failing-with-monitor-open

davegarthsimpson · web-flow · commit 1e7fbf119a5f · 2022-06-15T15:35:54.000+02:00
diff --git a/arduino-ide-extension/src/browser/theia/core/application-shell.ts b/arduino-ide-extension/src/browser/theia/core/application-shell.ts
@@ -130,5 +130,5 @@ DockPanel.prototype.handleEvent = function (event) {
       case 'p-drop':
         return;
   }
-  originalHandleEvent(event);
+  originalHandleEvent.bind(this)(event);
 };
diff --git a/arduino-ide-extension/src/browser/theia/preferences/preference-tree-generator.ts b/arduino-ide-extension/src/browser/theia/preferences/preference-tree-generator.ts
@@ -1,16 +1,43 @@
+import {
+  FrontendApplicationState,
+  FrontendApplicationStateService,
+} from '@theia/core/lib/browser/frontend-application-state';
 import { CompositeTreeNode } from '@theia/core/lib/browser/tree/tree';
-import { injectable } from '@theia/core/shared/inversify';
+import { inject, injectable } from '@theia/core/shared/inversify';
 import { PreferenceTreeGenerator as TheiaPreferenceTreeGenerator } from '@theia/preferences/lib/browser/util/preference-tree-generator';
 
 @injectable()
 export class PreferenceTreeGenerator extends TheiaPreferenceTreeGenerator {
+  private shouldHandleChangedSchemaOnReady = false;
+  private state: FrontendApplicationState | undefined;
+
+  @inject(FrontendApplicationStateService)
+  private readonly appStateService: FrontendApplicationStateService;
+
   protected override async init(): Promise<void> {
-    // The IDE2 does not use the default Theia preferences UI.
-    // There is no need to create and keep the the tree model synchronized when there is no UI for it.
+    this.appStateService.onStateChanged((state) => {
+      this.state = state;
+      // manually trigger a model (and UI) refresh if it was requested during the startup phase.
+      if (this.state === 'ready' && this.shouldHandleChangedSchemaOnReady) {
+        this.doHandleChangedSchema();
+      }
+    });
+    return super.init();
+  }
+
+  override doHandleChangedSchema(): void {
+    if (this.state === 'ready') {
+      super.doHandleChangedSchema();
+    }
+    // don't do anything until the app is `ready`, then invoke `doHandleChangedSchema`.
+    this.shouldHandleChangedSchemaOnReady = true;
   }
 
-  // Just returns with the empty root.
   override generateTree(): CompositeTreeNode {
+    if (this.state === 'ready') {
+      return super.generateTree();
+    }
+    // always create an empty root when the app is not ready.
     this._root = this.createRootNode();
     return this._root;
   }
diff --git a/arduino-ide-extension/src/node/core-client-provider.ts b/arduino-ide-extension/src/node/core-client-provider.ts
@@ -21,7 +21,10 @@ import {
 import * as commandsGrpcPb from './cli-protocol/cc/arduino/cli/commands/v1/commands_grpc_pb';
 import { NotificationServiceServer } from '../common/protocol';
 import { Deferred, retry } from '@theia/core/lib/common/promise-util';
-import { Status as RpcStatus } from './cli-protocol/google/rpc/status_pb';
+import {
+  Status as RpcStatus,
+  Status,
+} from './cli-protocol/google/rpc/status_pb';
 
 @injectable()
 export class CoreClientProvider extends GrpcClientProvider<CoreClientProvider.Client> {
@@ -90,10 +93,11 @@ export class CoreClientProvider extends GrpcClientProvider<CoreClientProvider.Cl
           this._initialized.resolve();
           this.updateIndex(this._client); // Update the indexes asynchronously
         } catch (error: unknown) {
-          if (
-            this.isPackageIndexMissingError(error) ||
-            this.isDiscoveryNotFoundError(error)
-          ) {
+          console.error(
+            'Error occurred while initializing the core gRPC client provider',
+            error
+          );
+          if (error instanceof IndexUpdateRequiredBeforeInitError) {
             // If it's a first start, IDE2 must run index update before the init request.
             await this.updateIndexes(this._client);
             await this.initInstance(this._client);
@@ -114,41 +118,6 @@ export class CoreClientProvider extends GrpcClientProvider<CoreClientProvider.Cl
     });
   }
 
-  private isPackageIndexMissingError(error: unknown): boolean {
-    const assert = (message: string) =>
-      message.includes('loading json index file');
-    // https://github.com/arduino/arduino-cli/blob/f0245bc2da6a56fccea7b2c9ea09e85fdcc52cb8/arduino/cores/packagemanager/package_manager.go#L247
-    return this.isRpcStatusError(error, assert);
-  }
-
-  private isDiscoveryNotFoundError(error: unknown): boolean {
-    const assert = (message: string) =>
-      message.includes('discovery') &&
-      (message.includes('not found') || message.includes('not installed'));
-    // https://github.com/arduino/arduino-cli/blob/f0245bc2da6a56fccea7b2c9ea09e85fdcc52cb8/arduino/cores/packagemanager/loader.go#L740
-    // https://github.com/arduino/arduino-cli/blob/f0245bc2da6a56fccea7b2c9ea09e85fdcc52cb8/arduino/cores/packagemanager/loader.go#L744
-    return this.isRpcStatusError(error, assert);
-  }
-
-  private isCancelError(error: unknown): boolean {
-    return (
-      error instanceof Error &&
-      error.message.toLocaleLowerCase().includes('cancelled on client')
-    );
-  }
-
-  // Final error codes are not yet defined by the CLI. Hence, we do string matching in the message RPC status.
-  private isRpcStatusError(
-    error: unknown,
-    assert: (message: string) => boolean
-  ) {
-    if (error instanceof RpcStatus) {
-      const { message } = RpcStatus.toObject(false, error);
-      return assert(message.toLocaleLowerCase());
-    }
-    return false;
-  }
-
   protected async createClient(
     port: string | number
   ): Promise<CoreClientProvider.Client> {
@@ -192,7 +161,7 @@ export class CoreClientProvider extends GrpcClientProvider<CoreClientProvider.Cl
     initReq.setInstance(instance);
     return new Promise<void>((resolve, reject) => {
       const stream = client.init(initReq);
-      const errorStatus: RpcStatus[] = [];
+      const errors: RpcStatus[] = [];
       stream.on('data', (res: InitResponse) => {
         const progress = res.getInitProgress();
         if (progress) {
@@ -210,28 +179,30 @@ export class CoreClientProvider extends GrpcClientProvider<CoreClientProvider.Cl
 
         const error = res.getError();
         if (error) {
-          console.error(error.getMessage());
-          errorStatus.push(error);
-          // Cancel the init request. No need to wait until the end of the event. The init has already failed.
-          // Canceling the request will result in a cancel error, but we need to reject with the original error later.
-          stream.cancel();
+          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', (error) => {
-        // On any error during the init request, the request is canceled.
-        // On cancel, the IDE2 ignores the cancel error and rejects with the original one.
-        reject(
-          this.isCancelError(error) && errorStatus.length
-            ? errorStatus[0]
-            : error
-        );
+      stream.on('error', reject);
+      stream.on('end', () => {
+        const error = this.evaluateErrorStatus(errors);
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
       });
-      stream.on('end', () =>
-        errorStatus.length ? reject(errorStatus) : resolve()
-      );
     });
   }
 
+  private evaluateErrorStatus(status: RpcStatus[]): Error | undefined {
+    const error = isIndexUpdateRequiredBeforeInit(status); // put future error matching here
+    return error;
+  }
+
   protected async updateIndexes(
     client: CoreClientProvider.Client
   ): Promise<CoreClientProvider.Client> {
@@ -338,3 +309,58 @@ export abstract class CoreClientAware {
     );
   }
 }
+
+class IndexUpdateRequiredBeforeInitError extends Error {
+  constructor(causes: RpcStatus.AsObject[]) {
+    super(`The index of the cores and libraries must be updated before initializing the core gRPC client.
+The following problems were detected during the gRPC client initialization:
+${causes
+  .map(({ code, message }) => ` - code: ${code}, message: ${message}`)
+  .join('\n')}
+`);
+    Object.setPrototypeOf(this, IndexUpdateRequiredBeforeInitError.prototype);
+    if (!causes.length) {
+      throw new Error(`expected non-empty 'causes'`);
+    }
+  }
+}
+
+function isIndexUpdateRequiredBeforeInit(
+  status: RpcStatus[]
+): IndexUpdateRequiredBeforeInitError | undefined {
+  const causes = status
+    .filter((s) =>
+      IndexUpdateRequiredBeforeInit.map((predicate) => predicate(s)).some(
+        Boolean
+      )
+    )
+    .map((s) => RpcStatus.toObject(false, s));
+  return causes.length
+    ? new IndexUpdateRequiredBeforeInitError(causes)
+    : undefined;
+}
+const IndexUpdateRequiredBeforeInit = [
+  isPackageIndexMissingStatus,
+  isDiscoveryNotFoundStatus,
+];
+function isPackageIndexMissingStatus(status: RpcStatus): boolean {
+  const predicate = ({ message }: RpcStatus.AsObject) =>
+    message.includes('loading json index file');
+  // https://github.com/arduino/arduino-cli/blob/f0245bc2da6a56fccea7b2c9ea09e85fdcc52cb8/arduino/cores/packagemanager/package_manager.go#L247
+  return evaluate(status, predicate);
+}
+function isDiscoveryNotFoundStatus(status: RpcStatus): boolean {
+  const predicate = ({ message }: RpcStatus.AsObject) =>
+    message.includes('discovery') &&
+    (message.includes('not found') || message.includes('not installed'));
+  // https://github.com/arduino/arduino-cli/blob/f0245bc2da6a56fccea7b2c9ea09e85fdcc52cb8/arduino/cores/packagemanager/loader.go#L740
+  // https://github.com/arduino/arduino-cli/blob/f0245bc2da6a56fccea7b2c9ea09e85fdcc52cb8/arduino/cores/packagemanager/loader.go#L744
+  return evaluate(status, predicate);
+}
+function evaluate(
+  subject: RpcStatus,
+  predicate: (error: RpcStatus.AsObject) => boolean
+): boolean {
+  const status = RpcStatus.toObject(false, subject);
+  return predicate(status);
+}
diff --git a/arduino-ide-extension/src/node/core-service-impl.ts b/arduino-ide-extension/src/node/core-service-impl.ts
@@ -25,7 +25,9 @@ import { firstToUpperCase, firstToLowerCase } from '../common/utils';
 import { Port } from './cli-protocol/cc/arduino/cli/commands/v1/port_pb';
 import { nls } from '@theia/core';
 import { MonitorManager } from './monitor-manager';
+import { SimpleBuffer } from './utils/simple-buffer';
 
+const FLUSH_OUTPUT_MESSAGES_TIMEOUT_MS = 32;
 @injectable()
 export class CoreServiceImpl extends CoreClientAware implements CoreService {
   @inject(ResponseService)
@@ -73,18 +75,25 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
     this.mergeSourceOverrides(compileReq, options);
 
     const result = client.compile(compileReq);
+
+    const compileBuffer = new SimpleBuffer(
+      this.flushOutputPanelMessages.bind(this),
+      FLUSH_OUTPUT_MESSAGES_TIMEOUT_MS
+    );
     try {
       await new Promise<void>((resolve, reject) => {
         result.on('data', (cr: CompileResponse) => {
-          this.responseService.appendToOutput({
-            chunk: Buffer.from(cr.getOutStream_asU8()).toString(),
-          });
-          this.responseService.appendToOutput({
-            chunk: Buffer.from(cr.getErrStream_asU8()).toString(),
-          });
+          compileBuffer.addChunk(cr.getOutStream_asU8());
+          compileBuffer.addChunk(cr.getErrStream_asU8());
+        });
+        result.on('error', (error) => {
+          compileBuffer.clearFlushInterval();
+          reject(error);
+        });
+        result.on('end', () => {
+          compileBuffer.clearFlushInterval();
+          resolve();
         });
-        result.on('error', (error) => reject(error));
-        result.on('end', () => resolve());
       });
       this.responseService.appendToOutput({
         chunk: '\n--------------------------\nCompilation complete.\n',
@@ -176,17 +185,24 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
 
       const result = responseHandler(client, req);
 
+      const uploadBuffer = new SimpleBuffer(
+        this.flushOutputPanelMessages.bind(this),
+        FLUSH_OUTPUT_MESSAGES_TIMEOUT_MS
+      );
+
       await new Promise<void>((resolve, reject) => {
         result.on('data', (resp: UploadResponse) => {
-          this.responseService.appendToOutput({
-            chunk: Buffer.from(resp.getOutStream_asU8()).toString(),
-          });
-          this.responseService.appendToOutput({
-            chunk: Buffer.from(resp.getErrStream_asU8()).toString(),
-          });
+          uploadBuffer.addChunk(resp.getOutStream_asU8());
+          uploadBuffer.addChunk(resp.getErrStream_asU8());
+        });
+        result.on('error', (error) => {
+          uploadBuffer.clearFlushInterval();
+          reject(error);
+        });
+        result.on('end', () => {
+          uploadBuffer.clearFlushInterval();
+          resolve();
         });
-        result.on('error', (error) => reject(error));
-        result.on('end', () => resolve());
       });
       this.responseService.appendToOutput({
         chunk:
@@ -240,18 +256,25 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
     burnReq.setVerify(options.verify);
     burnReq.setVerbose(options.verbose);
     const result = client.burnBootloader(burnReq);
+
+    const bootloaderBuffer = new SimpleBuffer(
+      this.flushOutputPanelMessages.bind(this),
+      FLUSH_OUTPUT_MESSAGES_TIMEOUT_MS
+    );
     try {
       await new Promise<void>((resolve, reject) => {
         result.on('data', (resp: BurnBootloaderResponse) => {
-          this.responseService.appendToOutput({
-            chunk: Buffer.from(resp.getOutStream_asU8()).toString(),
-          });
-          this.responseService.appendToOutput({
-            chunk: Buffer.from(resp.getErrStream_asU8()).toString(),
-          });
+          bootloaderBuffer.addChunk(resp.getOutStream_asU8());
+          bootloaderBuffer.addChunk(resp.getErrStream_asU8());
+        });
+        result.on('error', (error) => {
+          bootloaderBuffer.clearFlushInterval();
+          reject(error);
+        });
+        result.on('end', () => {
+          bootloaderBuffer.clearFlushInterval();
+          resolve();
         });
-        result.on('error', (error) => reject(error));
-        result.on('end', () => resolve());
       });
     } catch (e) {
       const errorMessage = nls.localize(
@@ -283,4 +306,10 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
       }
     }
   }
+
+  private flushOutputPanelMessages(chunk: string): void {
+    this.responseService.appendToOutput({
+      chunk,
+    });
+  }
 }
diff --git a/arduino-ide-extension/src/node/utils/simple-buffer.ts b/arduino-ide-extension/src/node/utils/simple-buffer.ts
@@ -0,0 +1,31 @@
+export class SimpleBuffer {
+  private chunks: Uint8Array[] = [];
+
+  private flushInterval?: NodeJS.Timeout;
+
+  constructor(onFlush: (chunk: string) => void, flushTimeout: number) {
+    this.flushInterval = setInterval(() => {
+      if (this.chunks.length > 0) {
+        const chunkString = Buffer.concat(this.chunks).toString();
+        this.clearChunks();
+
+        onFlush(chunkString);
+      }
+    }, flushTimeout);
+  }
+
+  public addChunk(chunk: Uint8Array): void {
+    this.chunks.push(chunk);
+  }
+
+  private clearChunks(): void {
+    this.chunks = [];
+  }
+
+  public clearFlushInterval(): void {
+    this.clearChunks();
+
+    clearInterval(this.flushInterval);
+    this.flushInterval = undefined;
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -130,5 +130,5 @@ DockPanel.prototype.handleEvent = function (event) {`
`130`	`130`	`case 'p-drop':`
`131`	`131`	`return;`
`132`	`132`	`}`
`133`		`- originalHandleEvent(event);`
	`133`	`+ originalHandleEvent.bind(this)(event);`
`134`	`134`	`};`