Merge VS Code 1.23.1 (#1520)

src/vs/base/node/zip.ts

@@ -3,14 +3,15 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import nls = require('vs/nls');
+import * as nls from 'vs/nls';
 import * as path from 'path';
-import { createWriteStream } from 'fs';
+import { createWriteStream, WriteStream } from 'fs';
 import { Readable } from 'stream';
 import { nfcall, ninvoke, SimpleThrottler } from 'vs/base/common/async';
 import { mkdirp, rimraf } from 'vs/base/node/pfs';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { open as _openZip, Entry, ZipFile } from 'yauzl';
+import { ILogService } from 'vs/platform/log/common/log';
 
 export interface IExtractOptions {
 	overwrite?: boolean;
@@ -26,10 +27,7 @@ interface IOptions {
 	sourcePathRegex: RegExp;
 }
 
-export enum ExtractErrorType {
-	Undefined,
-	CorruptZip
-}
+export type ExtractErrorType = 'CorruptZip' | 'Incomplete';
 
 export class ExtractError extends Error {
 
@@ -40,7 +38,7 @@ export class ExtractError extends Error {
 		let message = cause.message;
 
 		switch (type) {
-			case ExtractErrorType.CorruptZip: message = `Corrupt ZIP: ${message}`; break;
+			case 'CorruptZip': message = `Corrupt ZIP: ${message}`; break;
 		}
 
 		super(message);
@@ -58,12 +56,14 @@ function modeFromEntry(entry: Entry) {
 }
 
 function toExtractError(err: Error): ExtractError {
-	let type = ExtractErrorType.CorruptZip;
+	if (err instanceof ExtractError) {
+		return err;
+	}
 
-	console.log('WHAT');
+	let type: ExtractErrorType = void 0;
 
 	if (/end of central directory record signature not found/.test(err.message)) {
-		type = ExtractErrorType.CorruptZip;
+		type = 'CorruptZip';
 	}
 
 	return new ExtractError(type, err);
@@ -74,24 +74,51 @@ function extractEntry(stream: Readable, fileName: string, mode: number, targetPa
 	const targetDirName = path.join(targetPath, dirName);
 	const targetFileName = path.join(targetPath, fileName);
 
+	let istream: WriteStream;
 	return mkdirp(targetDirName).then(() => new TPromise((c, e) => {
-		let istream = createWriteStream(targetFileName, { mode });
-		istream.once('finish', () => c(null));
+		istream = createWriteStream(targetFileName, { mode });
+		istream.once('close', () => c(null));
 		istream.once('error', e);
 		stream.once('error', e);
 		stream.pipe(istream);
+	}, () => {
+		if (istream) {
+			istream.close();
+		}
 	}));
 }
 
-function extractZip(zipfile: ZipFile, targetPath: string, options: IOptions): TPromise<void> {
+function extractZip(zipfile: ZipFile, targetPath: string, options: IOptions, logService: ILogService): TPromise<void> {
+	let isCanceled = false;
+	let last = TPromise.wrap<any>(null);
+	let extractedEntriesCount = 0;
+
 	return new TPromise((c, e) => {
 		const throttler = new SimpleThrottler();
-		let last = TPromise.as<any>(null);
+
+		const readNextEntry = () => {
+			extractedEntriesCount++;
+			zipfile.readEntry();
+		};
 
 		zipfile.once('error', e);
-		zipfile.once('close', () => last.then(c, e));
+		zipfile.once('close', () => last.then(() => {
+			if (isCanceled || zipfile.entryCount === extractedEntriesCount) {
+				c(null);
+			} else {
+				e(new ExtractError('Incomplete', new Error(nls.localize('incompleteExtract', "Incomplete. Found {0} of {1} entries", extractedEntriesCount, zipfile.entryCount))));
+			}
+		}, e));
+		zipfile.readEntry();
 		zipfile.on('entry', (entry: Entry) => {
+			logService.debug(targetPath, 'Found', entry.fileName);
+
+			if (isCanceled) {
+				return;
+			}
+
 			if (!options.sourcePathRegex.test(entry.fileName)) {
+				readNextEntry();
 				return;
 			}
 
@@ -100,33 +127,38 @@ function extractZip(zipfile: ZipFile, targetPath: string, options: IOptions): TP
 			// directory file names end with '/'
 			if (/\/$/.test(fileName)) {
 				const targetFileName = path.join(targetPath, fileName);
-				last = mkdirp(targetFileName);
+				last = mkdirp(targetFileName).then(() => readNextEntry());
 				return;
 			}
 
 			const stream = ninvoke(zipfile, zipfile.openReadStream, entry);
 			const mode = modeFromEntry(entry);
 
-			last = throttler.queue(() => stream.then(stream => extractEntry(stream, fileName, mode, targetPath, options)));
+			last = throttler.queue(() => stream.then(stream => extractEntry(stream, fileName, mode, targetPath, options).then(() => readNextEntry())));
 		});
+	}, () => {
+		logService.debug(targetPath, 'Cancelled.');
+		isCanceled = true;
+		last.cancel();
+		zipfile.close();
 	}).then(null, err => TPromise.wrapError(toExtractError(err)));
 }
 
-function openZip(zipFile: string): TPromise<ZipFile> {
-	return nfcall<ZipFile>(_openZip, zipFile)
+function openZip(zipFile: string, lazy: boolean = false): TPromise<ZipFile> {
+	return nfcall<ZipFile>(_openZip, zipFile, lazy ? { lazyEntries: true } : void 0)
 		.then(null, err => TPromise.wrapError(toExtractError(err)));
 }
 
-export function extract(zipPath: string, targetPath: string, options: IExtractOptions = {}): TPromise<void> {
+export function extract(zipPath: string, targetPath: string, options: IExtractOptions = {}, logService: ILogService): TPromise<void> {
 	const sourcePathRegex = new RegExp(options.sourcePath ? `^${options.sourcePath}` : '');
 
-	let promise = openZip(zipPath);
+	let promise = openZip(zipPath, true);
 
 	if (options.overwrite) {
 		promise = promise.then(zipfile => rimraf(targetPath).then(() => zipfile));
 	}
 
-	return promise.then(zipfile => extractZip(zipfile, targetPath, { sourcePathRegex }));
+	return promise.then(zipfile => extractZip(zipfile, targetPath, { sourcePathRegex }, logService));
 }
 
 function read(zipPath: string, filePath: string): TPromise<Readable> {