Vscode merge (#4582)

* Merge from vscode 37cb23d3dd4f9433d56d4ba5ea3203580719a0bd

* fix issues with merges

* bump node version in azpipe

* replace license headers

* remove duplicate launch task

* fix build errors

* fix build errors

* fix tslint issues

* working through package and linux build issues

* more work

* wip

* fix packaged builds

* working through linux build errors

* wip

* wip

* wip

* fix mac and linux file limits

* iterate linux pipeline

* disable editor typing

* revert series to parallel

* remove optimize vscode from linux

* fix linting issues

* revert testing change

* add work round for new node

* readd packaging for extensions

* fix issue with angular not resolving decorator dependencies

src/vs/platform/update/electron-browser/updateService.ts

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IChannel } from 'vs/base/parts/ipc/common/ipc';
+import { Event, Emitter } from 'vs/base/common/event';
+import { IUpdateService, State } from 'vs/platform/update/common/update';
+import { IMainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
+import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
+
+export class UpdateService implements IUpdateService {
+
+	_serviceBrand: ServiceIdentifier<any>;
+
+	private _onStateChange = new Emitter<State>();
+	get onStateChange(): Event<State> { return this._onStateChange.event; }
+
+	private _state: State = State.Uninitialized;
+	get state(): State { return this._state; }
+
+	private channel: IChannel;
+
+	constructor(@IMainProcessService mainProcessService: IMainProcessService) {
+		this.channel = mainProcessService.getChannel('update');
+
+		// always set this._state as the state changes
+		this.onStateChange(state => this._state = state);
+
+		this.channel.call<State>('_getInitialState').then(state => {
+			// fire initial state
+			this._onStateChange.fire(state);
+
+			// fire subsequent states as they come in from remote
+
+			this.channel.listen<State>('onStateChange')(state => this._onStateChange.fire(state));
+		});
+	}
+
+	checkForUpdates(context: any): Promise<void> {
+		return this.channel.call('checkForUpdates', context);
+	}
+
+	downloadUpdate(): Promise<void> {
+		return this.channel.call('downloadUpdate');
+	}
+
+	applyUpdate(): Promise<void> {
+		return this.channel.call('applyUpdate');
+	}
+
+	quitAndInstall(): Promise<void> {
+		return this.channel.call('quitAndInstall');
+	}
+
+	isLatestVersion(): Promise<boolean> {
+		return this.channel.call('isLatestVersion');
+	}
+}

src/vs/platform/update/electron-main/abstractUpdateService.ts

@@ -5,9 +5,9 @@
 
 import { Event, Emitter } from 'vs/base/common/event';
 import { timeout } from 'vs/base/common/async';
-import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { IConfigurationService, getMigratedSettingValue } from 'vs/platform/configuration/common/configuration';
 import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
-import product from 'vs/platform/node/product';
+import product from 'vs/platform/product/node/product';
 import { IUpdateService, State, StateType, AvailableForDownload, UpdateType } from 'vs/platform/update/common/update';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { ILogService } from 'vs/platform/log/common/log';
@@ -56,8 +56,8 @@ export abstract class AbstractUpdateService implements IUpdateService {
 			return;
 		}
 
-		const updateChannel = this.configurationService.getValue<string>('update.channel');
-		const quality = this.getProductQuality(updateChannel);
+		const updateMode = getMigratedSettingValue<string>(this.configurationService, 'update.mode', 'update.channel');
+		const quality = this.getProductQuality(updateMode);
 
 		if (!quality) {
 			this.logService.info('update#ctor - updates are disabled by user preference');
@@ -72,7 +72,7 @@ export abstract class AbstractUpdateService implements IUpdateService {
 
 		this.setState(State.Idle(this.getUpdateType()));
 
-		if (updateChannel === 'manual') {
+		if (updateMode === 'manual') {
 			this.logService.info('update#ctor - manual checks only; automatic updates are disabled by user preference');
 			return;
 		}
@@ -81,8 +81,8 @@ export abstract class AbstractUpdateService implements IUpdateService {
 		this.scheduleCheckForUpdates(30 * 1000).then(undefined, err => this.logService.error(err));
 	}
 
-	private getProductQuality(updateChannel: string): string | undefined {
-		return updateChannel === 'none' ? undefined : product.quality;
+	private getProductQuality(updateMode: string): string | undefined {
+		return updateMode === 'none' ? undefined : product.quality;
 	}
 
 	private scheduleCheckForUpdates(delay = 60 * 60 * 1000): Promise<void> {

src/vs/platform/update/electron-main/updateService.linux.ts

@@ -3,7 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import product from 'vs/platform/node/product';
+import product from 'vs/platform/product/node/product';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
 import { IRequestService } from 'vs/platform/request/node/request';
@@ -15,9 +15,6 @@ import { createUpdateURL, AbstractUpdateService } from 'vs/platform/update/elect
 import { asJson } from 'vs/base/node/request';
 import { shell } from 'electron';
 import { CancellationToken } from 'vs/base/common/cancellation';
-import * as path from 'path';
-import { spawn } from 'child_process';
-import { realpath } from 'fs';
 
 export class LinuxUpdateService extends AbstractUpdateService {
 
@@ -45,61 +42,36 @@ export class LinuxUpdateService extends AbstractUpdateService {
 
 		this.setState(State.CheckingForUpdates(context));
 
-		if (process.env.SNAP && process.env.SNAP_REVISION) {
-			this.checkForSnapUpdate();
-		} else {
-			this.requestService.request({ url: this.url }, CancellationToken.None)
-				.then<IUpdate>(asJson)
-				.then(update => {
-					if (!update || !update.url || !update.version || !update.productVersion) {
-						/* __GDPR__
-								"update:notAvailable" : {
-									"explicit" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true }
-								}
-							*/
-						this.telemetryService.publicLog('update:notAvailable', { explicit: !!context });
-
-						this.setState(State.Idle(UpdateType.Archive));
-					} else {
-						this.setState(State.AvailableForDownload(update));
-					}
-				})
-				.then(undefined, err => {
-					this.logService.error(err);
-
+		this.requestService.request({ url: this.url }, CancellationToken.None)
+			.then<IUpdate>(asJson)
+			.then(update => {
+				if (!update || !update.url || !update.version || !update.productVersion) {
 					/* __GDPR__
-						"update:notAvailable" : {
-							"explicit" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true }
-						}
+							"update:notAvailable" : {
+								"explicit" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true }
+							}
 						*/
 					this.telemetryService.publicLog('update:notAvailable', { explicit: !!context });
 
-					// only show message when explicitly checking for updates
-					const message: string | undefined = !!context ? (err.message || err) : undefined;
-					this.setState(State.Idle(UpdateType.Archive, message));
-				});
-		}
-	}
+					this.setState(State.Idle(UpdateType.Archive));
+				} else {
+					this.setState(State.AvailableForDownload(update));
+				}
+			})
+			.then(undefined, err => {
+				this.logService.error(err);
 
-	private checkForSnapUpdate(): void {
-		// If the application was installed as a snap, updates happen in the
-		// background automatically, we just need to check to see if an update
-		// has already happened.
-		realpath(`${path.dirname(process.env.SNAP!)}/current`, (err, resolvedCurrentSnapPath) => {
-			if (err) {
-				this.logService.error('update#checkForSnapUpdate(): Could not get realpath of application.');
-				return;
-			}
+				/* __GDPR__
+					"update:notAvailable" : {
+						"explicit" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true }
+					}
+					*/
+				this.telemetryService.publicLog('update:notAvailable', { explicit: !!context });
 
-			const currentRevision = path.basename(resolvedCurrentSnapPath);
-
-			if (process.env.SNAP_REVISION !== currentRevision) {
-				// TODO@joao: snap
-				this.setState(State.Ready({ version: '', productVersion: '' }));
-			} else {
-				this.setState(State.Idle(UpdateType.Archive));
-			}
-		});
+				// only show message when explicitly checking for updates
+				const message: string | undefined = !!context ? (err.message || err) : undefined;
+				this.setState(State.Idle(UpdateType.Archive, message));
+			});
 	}
 
 	protected async doDownloadUpdate(state: AvailableForDownload): Promise<void> {
@@ -113,23 +85,4 @@ export class LinuxUpdateService extends AbstractUpdateService {
 
 		this.setState(State.Idle(UpdateType.Archive));
 	}
-
-	protected doQuitAndInstall(): void {
-		this.logService.trace('update#quitAndInstall(): running raw#quitAndInstall()');
-
-		const snap = process.env.SNAP;
-
-		// TODO@joao what to do?
-		if (!snap) {
-			return;
-		}
-
-		// Allow 3 seconds for VS Code to close
-		spawn('sleep 3 && $SNAP_NAME', {
-			shell: true,
-			detached: true,
-			stdio: 'ignore',
-		});
-
-	}
 }

src/vs/platform/update/electron-main/updateService.snap.ts

@@ -9,7 +9,7 @@ import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycle
 import { IUpdateService, State, StateType, AvailableForDownload, UpdateType } from 'vs/platform/update/common/update';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { ILogService } from 'vs/platform/log/common/log';
-import * as path from 'path';
+import * as path from 'vs/base/common/path';
 import { realpath, watch } from 'fs';
 import { spawn } from 'child_process';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
@@ -190,7 +190,7 @@ export class SnapUpdateService extends AbstractUpdateService2 {
 		this.logService.trace('update#quitAndInstall(): running raw#quitAndInstall()');
 
 		// Allow 3 seconds for VS Code to close
-		spawn('sleep 3 && $SNAP_NAME', {
+		spawn('sleep 3 && ' + path.basename(process.argv[0]), {
 			shell: true,
 			detached: true,
 			stdio: 'ignore',

src/vs/platform/update/electron-main/updateService.win32.ts

@@ -4,13 +4,13 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as fs from 'fs';
-import * as path from 'path';
+import * as path from 'vs/base/common/path';
 import * as pfs from 'vs/base/node/pfs';
 import { memoize } from 'vs/base/common/decorators';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
 import { IRequestService } from 'vs/platform/request/node/request';
-import product from 'vs/platform/node/product';
+import product from 'vs/platform/product/node/product';
 import { State, IUpdate, StateType, AvailableForDownload, UpdateType } from 'vs/platform/update/common/update';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';

src/vs/platform/update/node/update.config.contribution.ts

@@ -14,12 +14,12 @@ configurationRegistry.registerConfiguration({
 	title: localize('updateConfigurationTitle', "Update"),
 	type: 'object',
 	properties: {
-		'update.channel': {
+		'update.mode': {
 			type: 'string',
 			enum: ['none', 'manual', 'default'],
 			default: 'default',
 			scope: ConfigurationScope.APPLICATION,
-			description: localize('updateChannel', "Configure whether you receive automatic updates from an update channel. Requires a restart after change. The updates are fetched from a Microsoft online service."),
+			description: localize('updateMode', "Configure whether you receive automatic updates. Requires a restart after change. The updates are fetched from a Microsoft online service."),
 			tags: ['usesOnlineServices'],
 			enumDescriptions: [
 				localize('none', "Disable updates."),
@@ -27,6 +27,13 @@ configurationRegistry.registerConfiguration({
 				localize('default', "Enable automatic update checks. Code will check for updates automatically and periodically.")
 			]
 		},
+		'update.channel': {
+			type: 'string',
+			default: 'default',
+			scope: ConfigurationScope.APPLICATION,
+			description: localize('updateMode', "Configure whether you receive automatic updates. Requires a restart after change. The updates are fetched from a Microsoft online service."),
+			deprecationMessage: localize('deprecated', "This setting is deprecated, please use '{0}' instead.", 'update.mode')
+		},
 		'update.enableWindowsBackgroundUpdates': {
 			type: 'boolean',
 			default: true,

src/vs/platform/update/node/updateIpc.ts

@@ -3,9 +3,9 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IChannel, IServerChannel } from 'vs/base/parts/ipc/node/ipc';
-import { Event, Emitter } from 'vs/base/common/event';
-import { IUpdateService, State } from 'vs/platform/update/common/update';
+import { IServerChannel } from 'vs/base/parts/ipc/common/ipc';
+import { Event } from 'vs/base/common/event';
+import { IUpdateService } from 'vs/platform/update/common/update';
 
 export class UpdateChannel implements IServerChannel {
 
@@ -31,49 +31,4 @@ export class UpdateChannel implements IServerChannel {
 
 		throw new Error(`Call not found: ${command}`);
 	}
-}
-
-export class UpdateChannelClient implements IUpdateService {
-
-	_serviceBrand: any;
-
-	private _onStateChange = new Emitter<State>();
-	get onStateChange(): Event<State> { return this._onStateChange.event; }
-
-	private _state: State = State.Uninitialized;
-	get state(): State { return this._state; }
-
-	constructor(private channel: IChannel) {
-		// always set this._state as the state changes
-		this.onStateChange(state => this._state = state);
-
-		channel.call<State>('_getInitialState').then(state => {
-			// fire initial state
-			this._onStateChange.fire(state);
-
-			// fire subsequent states as they come in from remote
-
-			this.channel.listen<State>('onStateChange')(state => this._onStateChange.fire(state));
-		});
-	}
-
-	checkForUpdates(context: any): Promise<void> {
-		return this.channel.call('checkForUpdates', context);
-	}
-
-	downloadUpdate(): Promise<void> {
-		return this.channel.call('downloadUpdate');
-	}
-
-	applyUpdate(): Promise<void> {
-		return this.channel.call('applyUpdate');
-	}
-
-	quitAndInstall(): Promise<void> {
-		return this.channel.call('quitAndInstall');
-	}
-
-	isLatestVersion(): Promise<boolean> {
-		return this.channel.call('isLatestVersion');
-	}
-}
+}