Merge pull request #1040 from telerik/vladimirov/disable-spinners-in-ci

Add getSpinner method to $progressIndicator

Author: rosen-vladimirov

declarations.d.ts

@@ -1564,6 +1564,38 @@ interface IProgressIndicator {
 	 * @return {Promise<T>}
 	 */
 	showProgressIndicator<T>(promise: Promise<T>, timeout: number, options?: { surpressTrailingNewLine?: boolean }): Promise<T>;
+
+	/**
+	 * Returns a spinner instance that will print a specified message when spinner is started and will repeat it until spinner is stopped.
+	 * In case the terminal is not interactive, a mocked instance is returned, so the spinner will print the required message a single time - when it is started.
+	 * @param {string} message The message to be printed.
+	 * @returns {ISpinner} Instance of clui.Spinner in case terminal is interactive, mocked instance otherwise.
+	 */
+	getSpinner(message: string): ISpinner;
+}
+
+/**
+ * Describes the clui spinner.
+ */
+interface ISpinner {
+	/**
+	 * Sets the message that will be printed by spinner.
+	 * @param {string} msg The new message.
+	 * @returns {void}
+	 */
+	message(msg: string): void;
+
+	/**
+	 * Starts the spinner.
+	 * @returns {void}
+	 */
+	start(): void;
+
+	/**
+	 * Stops the spinner.
+	 * @returns {void}
+	 */
+	stop(): void;
 }
 
 /**

helpers.ts

@@ -5,9 +5,53 @@ import { ReadStream } from "tty";
 import { Configurations } from "./constants";
 import { EventEmitter } from "events";
 import * as crypto from "crypto";
+import progress = require("progress-stream");
+import filesize = require("filesize");
+import * as util from "util";
 
 const Table = require("cli-table");
 
+export function trackDownloadProgress(destinationStream: NodeJS.WritableStream, url: string): NodeJS.ReadableStream {
+	// \r for carriage return doesn't work on windows in node for some reason so we have to use it's hex representation \x1B[0G
+	let lastMessageSize = 0;
+	const carriageReturn = "\x1B[0G";
+	let timeElapsed = 0;
+
+	const isInteractiveTerminal = isInteractive();
+	const progressStream = progress({ time: 1000 }, (progress: any) => {
+		timeElapsed = progress.runtime;
+
+		if (timeElapsed >= 1) {
+			if (isInteractiveTerminal) {
+				this.$logger.write("%s%s", carriageReturn, Array(lastMessageSize + 1).join(" "));
+
+				const message = util.format("%sDownload progress ... %s | %s | %s/s",
+					carriageReturn,
+					Math.floor(progress.percentage) + "%",
+					filesize(progress.transferred),
+					filesize(progress.speed));
+
+				this.$logger.write(message);
+				lastMessageSize = message.length;
+			}
+		}
+	});
+
+	progressStream.on("finish", () => {
+		if (timeElapsed >= 1) {
+			const msg = `Download of ${url} completed.`;
+			if (isInteractiveTerminal) {
+				this.$logger.out("%s%s%s%s", carriageReturn, Array(lastMessageSize + 1).join(" "), carriageReturn, msg);
+			} else {
+				this.$logger.out(msg);
+			}
+		}
+	});
+
+	progressStream.pipe(destinationStream);
+	return progressStream;
+}
+
 export async function executeActionByChunks<T>(initialData: T[] | IDictionary<T>, chunkSize: number, elementAction: (element: T, key?: string | number) => Promise<any>): Promise<void> {
 	let arrayToChunk: (T | string)[];
 	let action: (key: string | T) => Promise<any>;

http-client.ts

@@ -3,8 +3,6 @@ import { EOL } from "os";
 import * as helpers from "./helpers";
 import * as zlib from "zlib";
 import * as util from "util";
-import progress = require("progress-stream");
-import filesize = require("filesize");
 import { HttpStatusCodes } from "./constants";
 import * as request from "request";
 
@@ -133,8 +131,6 @@ export class HttpClient implements Server.IHttpClient {
 							this.setResponseResult(promiseActions, timerId, { response });
 						});
 
-						pipeTo = this.trackDownloadProgress(pipeTo);
-
 						responseStream.pipe(pipeTo);
 					} else {
 						const data: string[] = [];
@@ -204,39 +200,6 @@ export class HttpClient implements Server.IHttpClient {
 		}
 	}
 
-	private trackDownloadProgress(pipeTo: NodeJS.WritableStream): NodeJS.ReadableStream {
-		// \r for carriage return doesn't work on windows in node for some reason so we have to use it's hex representation \x1B[0G
-		let lastMessageSize = 0;
-		const carriageReturn = "\x1B[0G";
-		let timeElapsed = 0;
-
-		const progressStream = progress({ time: 1000 }, (progress: any) => {
-			timeElapsed = progress.runtime;
-
-			if (timeElapsed >= 1) {
-				this.$logger.write("%s%s", carriageReturn, Array(lastMessageSize + 1).join(" "));
-
-				const message = util.format("%sDownload progress ... %s | %s | %s/s",
-					carriageReturn,
-					Math.floor(progress.percentage) + "%",
-					filesize(progress.transferred),
-					filesize(progress.speed));
-
-				this.$logger.write(message);
-				lastMessageSize = message.length;
-			}
-		});
-
-		progressStream.on("finish", () => {
-			if (timeElapsed >= 1) {
-				this.$logger.out("%s%s%s%s", carriageReturn, Array(lastMessageSize + 1).join(" "), carriageReturn, "Download completed.");
-			}
-		});
-
-		progressStream.pipe(pipeTo);
-		return progressStream;
-	}
-
 	private getErrorMessage(statusCode: number, body: string): string {
 		if (statusCode === HttpStatusCodes.PROXY_AUTHENTICATION_REQUIRED) {
 			const clientNameLowerCase = this.$staticConfig.CLIENT_NAME.toLowerCase();

progress-indicator.ts

@@ -1,23 +1,29 @@
+import { isInteractive } from './helpers';
+
+const clui = require("clui");
+
 export class ProgressIndicator implements IProgressIndicator {
 	constructor(private $logger: ILogger) { }
 
 	public async showProgressIndicator<T>(promise: Promise<T>, timeout: number, options?: { surpressTrailingNewLine?: boolean }): Promise<T> {
 		const surpressTrailingNewLine = options && options.surpressTrailingNewLine;
 
-		let isResolved = false;
+		let isFulfilled = false;
 
 		const tempPromise = new Promise<T>((resolve, reject) => {
 			promise.then((res) => {
-				isResolved = true;
+				isFulfilled = true;
 				resolve(res);
 			}, (err) => {
-				isResolved = true;
+				isFulfilled = true;
 				reject(err);
 			});
 		});
 
-		while (!isResolved) {
-			await this.$logger.printMsgWithTimeout(".", timeout);
+		if (!isInteractive()) {
+			while (!isFulfilled) {
+				await this.$logger.printMsgWithTimeout(".", timeout);
+			}
 		}
 
 		if (!surpressTrailingNewLine) {
@@ -26,5 +32,18 @@ export class ProgressIndicator implements IProgressIndicator {
 
 		return tempPromise;
 	}
+
+	public getSpinner(message: string): ISpinner {
+		if (isInteractive()) {
+			return new clui.Spinner(message);
+		} else {
+			let msg = message;
+			return {
+				start: () => this.$logger.info(msg),
+				message: (newMsg: string) => msg = newMsg,
+				stop: (): void => undefined
+			};
+		}
+	}
 }
 $injector.register("progressIndicator", ProgressIndicator);