create buffer provider

Author: davegarthsimpson

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

@@ -25,6 +25,7 @@ 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 { OutputPanelBufferProvider } from './output-panel-buffer-provider';
 
 @injectable()
 export class CoreServiceImpl extends CoreClientAware implements CoreService {
@@ -39,25 +40,8 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
 
   protected uploading = false;
 
-  private outputString: string;
-
   private FLUSH_OUTPUT_MESSAGES_TIMEOUT_MS = 32;
 
-  private flushOutputMessagesInterval?: NodeJS.Timeout;
-
-  setOutputMessagesInterval(): void {
-    this.flushOutputMessagesInterval = setInterval(() => {
-      this.responseService.appendToOutput({
-        chunk: this.outputString,
-      });
-    }, this.FLUSH_OUTPUT_MESSAGES_TIMEOUT_MS);
-  }
-
-  clearOutputMessagesInterval(): void {
-    clearInterval(this.flushOutputMessagesInterval);
-    this.flushOutputMessagesInterval = undefined;
-  }
-
   async compile(
     options: CoreService.Compile.Options & {
       exportBinaries?: boolean;
@@ -92,18 +76,25 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
     this.mergeSourceOverrides(compileReq, options);
 
     const result = client.compile(compileReq);
+
+    const compileBuffer = new OutputPanelBufferProvider(
+      this.flushOutputPanelMessages,
+      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',
@@ -193,19 +184,22 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
 
     const result = responseHandler(client, req);
 
-    this.setOutputMessagesInterval();
-
+    const uploadBuffer = new OutputPanelBufferProvider(
+      this.flushOutputPanelMessages,
+      this.FLUSH_OUTPUT_MESSAGES_TIMEOUT_MS
+    );
     try {
       await new Promise<void>((resolve, reject) => {
         result.on('data', (resp: UploadResponse) => {
-          this.outputString =
-            this.outputString +
-            Buffer.from(resp.getOutStream_asU8()).toString() +
-            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('error', (error) => reject(error));
         result.on('end', () => {
-          this.clearOutputMessagesInterval();
+          uploadBuffer.clearFlushInterval();
           resolve();
         });
       });
@@ -260,18 +254,25 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
     burnReq.setVerify(options.verify);
     burnReq.setVerbose(options.verbose);
     const result = client.burnBootloader(burnReq);
+
+    const bootloaderBuffer = new OutputPanelBufferProvider(
+      this.flushOutputPanelMessages,
+      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(
@@ -303,4 +304,13 @@ export class CoreServiceImpl extends CoreClientAware implements CoreService {
       }
     }
   }
+
+  private flushOutputPanelMessages(chunk: string): void {
+    this.responseService.appendToOutput({
+      chunk,
+    });
+    this.responseService.appendToOutput({
+      chunk,
+    });
+  }
 }

Diff for: arduino-ide-extension/src/node/output-panel-buffer-provider.ts

@@ -0,0 +1,28 @@
+export class OutputPanelBufferProvider {
+  chunks: Uint8Array[] = [];
+
+  private flushInterval?: NodeJS.Timeout;
+
+  constructor(onFlush: (chunk: string) => void, flushTimeout: number) {
+    this.flushInterval = setInterval(() => {
+      const chunkString = Buffer.concat(this.chunks).toString();
+      onFlush(chunkString);
+      this.clearChunks();
+    }, flushTimeout);
+  }
+
+  public addChunk(chunk: Uint8Array): void {
+    this.chunks.push(chunk);
+  }
+
+  private clearChunks() {
+    this.chunks = [];
+  }
+
+  public clearFlushInterval(): void {
+    this.clearChunks();
+
+    clearInterval(this.flushInterval);
+    this.flushInterval = undefined;
+  }
+}