unknown progress for upload kinds

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

Author: Akos Kitta

arduino-ide-extension/src/browser/contributions/upload-sketch.ts

@@ -3,10 +3,8 @@ import { Emitter } from '@theia/core/lib/common/event';
 import { BoardUserField, CoreService } from '../../common/protocol';
 import { ArduinoMenus, PlaceholderMenuNode } from '../menu/arduino-menus';
 import { ArduinoToolbar } from '../toolbar/arduino-toolbar';
-import { BoardsDataStore } from '../boards/boards-data-store';
 import { BoardsServiceProvider } from '../boards/boards-service-provider';
 import {
-  CoreServiceContribution,
   Command,
   CommandRegistry,
   MenuModelRegistry,
@@ -16,16 +14,13 @@ import {
 import { UserFieldsDialog } from '../dialogs/user-fields/user-fields-dialog';
 import { DisposableCollection, nls } from '@theia/core/lib/common';
 import { CurrentSketch } from '../../common/protocol/sketches-service-client-impl';
-import { VerifySketch } from './verify-sketch';
+import { VerifyParams, VerifySketch } from './verify-sketch';
 
 @injectable()
-export class UploadSketch extends CoreServiceContribution {
+export class UploadSketch extends VerifySketch {
   @inject(MenuModelRegistry)
   private readonly menuRegistry: MenuModelRegistry;
 
-  @inject(BoardsDataStore)
-  private readonly boardsDataStore: BoardsDataStore;
-
   @inject(BoardsServiceProvider)
   private readonly boardsServiceClientImpl: BoardsServiceProvider;
 
@@ -36,8 +31,9 @@ export class UploadSketch extends CoreServiceContribution {
   private readonly cachedUserFields: Map<string, BoardUserField[]> = new Map();
   private readonly menuActionsDisposables = new DisposableCollection();
 
-  private readonly onDidChangeEmitter = new Emitter<void>();
-  private readonly onDidChange = this.onDidChangeEmitter.event;
+  private readonly onUploadInProgressDidChangeEmitter = new Emitter<void>();
+  private readonly onUploadInProgressDidChange =
+    this.onUploadInProgressDidChangeEmitter.event;
   private uploadInProgress = false;
 
   protected override init(): void {
@@ -186,7 +182,7 @@ export class UploadSketch extends CoreServiceContribution {
       command: UploadSketch.Commands.UPLOAD_SKETCH_TOOLBAR.id,
       tooltip: nls.localize('arduino/sketch/upload', 'Upload'),
       priority: 1,
-      onDidChange: this.onDidChange,
+      onDidChange: this.onUploadInProgressDidChange,
     });
   }
 
@@ -195,16 +191,12 @@ export class UploadSketch extends CoreServiceContribution {
       return;
     }
 
-    const ref = await this.commandService.executeCommand<VerifySketch.Ref>(
-      VerifySketch.Commands.VERIFY_SKETCH.id,
-      false
-    );
-
-    if (!ref) {
+    const params = await this.verifySketch(false);
+    if (!params) {
       return;
     }
 
-    const options = await this.options(usingProgrammer, ref);
+    const options = await this.uploadOptions(usingProgrammer, params);
     if (!options) {
       return;
     }
@@ -224,7 +216,7 @@ export class UploadSketch extends CoreServiceContribution {
       // uploadInProgress will be set to false whether the upload fails or not
       this.uploadInProgress = true;
       this.coreErrorHandler.reset();
-      this.onDidChangeEmitter.fire();
+      this.onUploadInProgressDidChangeEmitter.fire();
       await this.doWithProgress({
         progressText: nls.localize('arduino/sketch/uploading', 'Uploading...'),
         task: (progressId, coreService) => {
@@ -241,13 +233,13 @@ export class UploadSketch extends CoreServiceContribution {
       this.handleError(e);
     } finally {
       this.uploadInProgress = false;
-      this.onDidChangeEmitter.fire();
+      this.onUploadInProgressDidChangeEmitter.fire();
     }
   }
 
-  private async options(
+  private async uploadOptions(
     usingProgrammer: boolean,
-    verifyRef: VerifySketch.Ref
+    params: VerifyParams
   ): Promise<CoreService.Options.Upload | undefined> {
     const sketch = await this.sketchServiceClient.currentSketch();
     if (!CurrentSketch.isValid(sketch)) {
@@ -257,8 +249,8 @@ export class UploadSketch extends CoreServiceContribution {
     const { boardsConfig } = this.boardsServiceClientImpl;
     const [fqbn, { selectedProgrammer: programmer }, verify, verbose] =
       await Promise.all([
-        verifyRef.fqbn.decorated,
-        this.boardsDataStore.getData(verifyRef.fqbn.original),
+        params.fqbn.decorated,
+        this.boardsDataStore.getData(params.fqbn.original),
         this.preferences.get('arduino.upload.verify'),
         this.preferences.get('arduino.upload.verbose'),
       ]);

arduino-ide-extension/src/browser/contributions/verify-sketch.ts

@@ -19,46 +19,47 @@ import { CoreService } from '../../common/protocol';
 @injectable()
 export class VerifySketch extends CoreServiceContribution {
   @inject(BoardsDataStore)
-  private readonly boardsDataStore: BoardsDataStore;
+  protected readonly boardsDataStore: BoardsDataStore;
 
   @inject(BoardsServiceProvider)
   private readonly boardsServiceProvider: BoardsServiceProvider;
 
-  private readonly onDidChangeEmitter = new Emitter<void>();
-  private readonly onDidChange = this.onDidChangeEmitter.event;
+  private readonly onVerifyInProgressDidChangeEmitter = new Emitter<void>();
+  private readonly onVerifyInProgressDidChange =
+    this.onVerifyInProgressDidChangeEmitter.event;
   private verifyInProgress = false;
 
   override registerCommands(registry: CommandRegistry): void {
-    registry.registerCommand(VerifySketch.Commands.VERIFY_SKETCH, {
+    registry.registerCommand(VerifySketchCommands.VERIFY_SKETCH, {
       execute: async (exportBinaries?: boolean) => {
         return this.verifySketch(exportBinaries);
       },
       isEnabled: () => !this.verifyInProgress,
     });
-    registry.registerCommand(VerifySketch.Commands.EXPORT_BINARIES, {
+    registry.registerCommand(VerifySketchCommands.EXPORT_BINARIES, {
       execute: async () => {
         return this.verifySketch(true);
       },
       isEnabled: () => !this.verifyInProgress,
     });
-    registry.registerCommand(VerifySketch.Commands.VERIFY_SKETCH_TOOLBAR, {
+    registry.registerCommand(VerifySketchCommands.VERIFY_SKETCH_TOOLBAR, {
       isVisible: (widget) =>
         ArduinoToolbar.is(widget) && widget.side === 'left',
       isEnabled: () => !this.verifyInProgress,
       isToggled: () => this.verifyInProgress,
       execute: () =>
-        registry.executeCommand(VerifySketch.Commands.VERIFY_SKETCH.id),
+        registry.executeCommand(VerifySketchCommands.VERIFY_SKETCH.id),
     });
   }
 
   override registerMenus(registry: MenuModelRegistry): void {
     registry.registerMenuAction(ArduinoMenus.SKETCH__MAIN_GROUP, {
-      commandId: VerifySketch.Commands.VERIFY_SKETCH.id,
+      commandId: VerifySketchCommands.VERIFY_SKETCH.id,
       label: nls.localize('arduino/sketch/verifyOrCompile', 'Verify/Compile'),
       order: '0',
     });
     registry.registerMenuAction(ArduinoMenus.SKETCH__MAIN_GROUP, {
-      commandId: VerifySketch.Commands.EXPORT_BINARIES.id,
+      commandId: VerifySketchCommands.EXPORT_BINARIES.id,
       label: nls.localize(
         'arduino/sketch/exportBinary',
         'Export Compiled Binary'
@@ -69,43 +70,43 @@ export class VerifySketch extends CoreServiceContribution {
 
   override registerKeybindings(registry: KeybindingRegistry): void {
     registry.registerKeybinding({
-      command: VerifySketch.Commands.VERIFY_SKETCH.id,
+      command: VerifySketchCommands.VERIFY_SKETCH.id,
       keybinding: 'CtrlCmd+R',
     });
     registry.registerKeybinding({
-      command: VerifySketch.Commands.EXPORT_BINARIES.id,
+      command: VerifySketchCommands.EXPORT_BINARIES.id,
       keybinding: 'CtrlCmd+Alt+S',
     });
   }
 
   override registerToolbarItems(registry: TabBarToolbarRegistry): void {
     registry.registerItem({
-      id: VerifySketch.Commands.VERIFY_SKETCH_TOOLBAR.id,
-      command: VerifySketch.Commands.VERIFY_SKETCH_TOOLBAR.id,
+      id: VerifySketchCommands.VERIFY_SKETCH_TOOLBAR.id,
+      command: VerifySketchCommands.VERIFY_SKETCH_TOOLBAR.id,
       tooltip: nls.localize('arduino/sketch/verify', 'Verify'),
       priority: 0,
-      onDidChange: this.onDidChange,
+      onDidChange: this.onVerifyInProgressDidChange,
     });
   }
 
-  private async verifySketch(
+  protected async verifySketch(
     exportBinaries?: boolean
-  ): Promise<undefined | VerifySketch.Ref> {
+  ): Promise<undefined | VerifyParams> {
     if (this.verifyInProgress) {
       return undefined;
     }
 
     const originalFqbn =
       this.boardsServiceProvider.boardsConfig.selectedBoard?.fqbn;
-    const options = await this.options(exportBinaries);
+    const options = await this.verifyOptions(exportBinaries);
     if (!options) {
       return undefined;
     }
 
     try {
       this.verifyInProgress = true;
       this.coreErrorHandler.reset();
-      this.onDidChangeEmitter.fire();
+      this.onVerifyInProgressDidChangeEmitter.fire();
       await this.doWithProgress({
         progressText: nls.localize(
           'arduino/sketch/compile',
@@ -132,11 +133,11 @@ export class VerifySketch extends CoreServiceContribution {
       return undefined;
     } finally {
       this.verifyInProgress = false;
-      this.onDidChangeEmitter.fire();
+      this.onVerifyInProgressDidChangeEmitter.fire();
     }
   }
 
-  private async options(
+  private async verifyOptions(
     exportBinaries?: boolean
   ): Promise<CoreService.Options.Compile | undefined> {
     const sketch = await this.sketchServiceClient.currentSketch();
@@ -165,20 +166,18 @@ export class VerifySketch extends CoreServiceContribution {
   }
 }
 
-export namespace VerifySketch {
-  export namespace Commands {
-    export const VERIFY_SKETCH: Command = {
-      id: 'arduino-verify-sketch',
-    };
-    export const EXPORT_BINARIES: Command = {
-      id: 'arduino-export-binaries',
-    };
-    export const VERIFY_SKETCH_TOOLBAR: Command = {
-      id: 'arduino-verify-sketch--toolbar',
-    };
-  }
-  export type Ref = CoreService.Options.SketchBased &
-    Readonly<{
-      fqbn: { original?: string | undefined; decorated?: string | undefined };
-    }>;
+export namespace VerifySketchCommands {
+  export const VERIFY_SKETCH: Command = {
+    id: 'arduino-verify-sketch',
+  };
+  export const EXPORT_BINARIES: Command = {
+    id: 'arduino-export-binaries',
+  };
+  export const VERIFY_SKETCH_TOOLBAR: Command = {
+    id: 'arduino-verify-sketch--toolbar',
+  };
 }
+export type VerifyParams = CoreService.Options.SketchBased &
+  Readonly<{
+    fqbn: { original?: string | undefined; decorated?: string | undefined };
+  }>;

arduino-ide-extension/src/node/core-service-impl.ts

@@ -33,7 +33,7 @@ import { tryParseError } from './cli-error-parser';
 import { Instance } from './cli-protocol/cc/arduino/cli/commands/v1/common_pb';
 import { firstToUpperCase, notEmpty } from '../common/utils';
 import { ServiceError } from './service-error';
-import { ExecuteWithProgress } from './grpc-progressible';
+import { ExecuteWithProgress, ProgressResponse } from './grpc-progressible';
 
 namespace Uploadable {
   export type Request = UploadRequest | UploadUsingProgrammerRequest;
@@ -55,13 +55,8 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
     const coreClient = await this.coreClient;
     const { client, instance } = coreClient;
     let buildPath: string | undefined = undefined;
-    const progressHandler =
-      !!options.progressId &&
-      ExecuteWithProgress.createDataCallback({
-        progressId: options.progressId,
-        responseService: this.responseService,
-      });
-    const handler = this.createOnDataHandler<CompileResponse>((response) => {
+    const progressHandler = this.createProgressHandler(options);
+    const buildPathHandler = (response: CompileResponse) => {
       if (progressHandler) {
         progressHandler(response);
       }
@@ -75,7 +70,11 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
           );
         }
       }
-    });
+    };
+    const handler = this.createOnDataHandler<CompileResponse>(
+      progressHandler,
+      buildPathHandler
+    );
     const request = this.compileRequest(options, instance);
     return new Promise<void>((resolve, reject) => {
       client
@@ -206,7 +205,8 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
   ): Promise<void> {
     const coreClient = await this.coreClient;
     const { client, instance } = coreClient;
-    const handler = this.createOnDataHandler();
+    const progressHandler = this.createProgressHandler(options);
+    const handler = this.createOnDataHandler(progressHandler);
     return this.notifyUploadWillStart(options).then(() =>
       new Promise<void>((resolve, reject) => {
         responseHandler(
@@ -273,7 +273,8 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
   async burnBootloader(options: CoreService.Options.Bootloader): Promise<void> {
     const coreClient = await this.coreClient;
     const { client, instance } = coreClient;
-    const handler = this.createOnDataHandler();
+    const progressHandler = this.createProgressHandler(options);
+    const handler = this.createOnDataHandler(progressHandler);
     const request = this.burnBootloaderRequest(options, instance);
     return this.notifyUploadWillStart(options).then(() =>
       new Promise<void>((resolve, reject) => {
@@ -328,8 +329,23 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
     return request;
   }
 
+  private createProgressHandler<R extends ProgressResponse>(
+    options: CoreService.Options.Base
+  ) {
+    // If client did not provide the progress ID, do nothing.
+    if (!options.progressId) {
+      return () => {
+        /* NOOP */
+      };
+    }
+    return ExecuteWithProgress.createDataCallback<R>({
+      progressId: options.progressId,
+      responseService: this.responseService,
+    });
+  }
+
   private createOnDataHandler<R extends StreamingResponse>(
-    onResponse?: (response: R) => void
+    ...handlers: ((response: R) => void)[] // TODO: clean up this API.
   ): Disposable & {
     stderr: Buffer[];
     onData: (response: R) => void;
@@ -348,7 +364,7 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
         buffer.addChunk(out);
         buffer.addChunk(err, OutputMessage.Severity.Error);
       },
-      onResponse,
+      handlers,
     });
     return {
       dispose: () => buffer.dispose(),
@@ -424,14 +440,17 @@ namespace StreamingResponse {
       const err = response.getErrStream_asU8();
       options.stderr.push(err);
       options.onData(out, err);
-      if (options.onResponse) {
-        options.onResponse(response);
-      }
+      options.handlers?.forEach((handler) => handler(response));
     };
   }
   export interface Options<R extends StreamingResponse> {
     readonly stderr: Uint8Array[];
     readonly onData: (out: Uint8Array, err: Uint8Array) => void;
-    readonly onResponse?: (response: R) => void;
+    /**
+     * Additional request handlers.
+     * For example, when tracing the progress of a task and
+     * collecting the output (out, err) and the `build_path` from the CLI.
+     */
+    readonly handlers?: ((response: R) => void)[];
   }
 }