app.ts 30.8 KB
Newer Older
1 2 3 4 5
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

6
import { app, ipcMain as ipc, systemPreferences, shell, Event, contentTracing, protocol, powerMonitor } from 'electron';
7
import { IProcessEnvironment, isWindows, isMacintosh } from 'vs/base/common/platform';
8
import { WindowsManager } from 'vs/code/electron-main/windows';
9
import { IWindowsService, OpenContext, ActiveWindowManager, IURIToOpen } from 'vs/platform/windows/common/windows';
J
Joao Moreno 已提交
10
import { WindowsChannel } from 'vs/platform/windows/node/windowsIpc';
11
import { WindowsService } from 'vs/platform/windows/electron-main/windowsService';
12
import { ILifecycleService, LifecycleMainPhase } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
B
Benjamin Pasero 已提交
13
import { getShellEnvironment } from 'vs/code/node/shellEnv';
14
import { IUpdateService } from 'vs/platform/update/common/update';
J
Joao Moreno 已提交
15
import { UpdateChannel } from 'vs/platform/update/node/updateIpc';
16
import { Server as ElectronIPCServer } from 'vs/base/parts/ipc/electron-main/ipc.electron-main';
A
Alex Dima 已提交
17 18
import { Client } from 'vs/base/parts/ipc/common/ipc.net';
import { Server, connect } from 'vs/base/parts/ipc/node/ipc.net';
19
import { SharedProcess } from 'vs/code/electron-main/sharedProcess';
B
Benjamin Pasero 已提交
20
import { LaunchService, LaunchChannel, ILaunchService } from 'vs/platform/launch/electron-main/launchService';
21 22 23
import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
24
import { ILogService } from 'vs/platform/log/common/log';
B
Benjamin Pasero 已提交
25
import { IStateService } from 'vs/platform/state/common/state';
26 27 28
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { IURLService } from 'vs/platform/url/common/url';
J
Joao Moreno 已提交
29
import { URLHandlerChannelClient, URLServiceChannel } from 'vs/platform/url/node/urlIpc';
30
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
31
import { NullTelemetryService, combinedAppender, LogAppender } from 'vs/platform/telemetry/common/telemetryUtils';
J
Joao Moreno 已提交
32
import { TelemetryAppenderClient } from 'vs/platform/telemetry/node/telemetryIpc';
33
import { TelemetryService, ITelemetryServiceConfig } from 'vs/platform/telemetry/common/telemetryService';
34
import { resolveCommonProperties } from 'vs/platform/telemetry/node/commonProperties';
A
Alex Dima 已提交
35
import { getDelayedChannel, StaticRouter } from 'vs/base/parts/ipc/common/ipc';
36 37
import product from 'vs/platform/product/node/product';
import pkg from 'vs/platform/product/node/package';
38
import { ProxyAuthHandler } from 'vs/code/electron-main/auth';
39
import { Disposable } from 'vs/base/common/lifecycle';
B
Benjamin Pasero 已提交
40
import { ConfigurationService } from 'vs/platform/configuration/node/configurationService';
B
Benjamin Pasero 已提交
41
import { IWindowsMainService, ICodeWindow } from 'vs/platform/windows/electron-main/windows';
B
Benjamin Pasero 已提交
42
import { IHistoryMainService } from 'vs/platform/history/common/history';
43
import { withUndefinedAsNull } from 'vs/base/common/types';
44
import { URI } from 'vs/base/common/uri';
J
Joao Moreno 已提交
45
import { WorkspacesChannel } from 'vs/platform/workspaces/node/workspacesIpc';
M
Martin Aeschlimann 已提交
46
import { IWorkspacesMainService, hasWorkspaceFileExtension } from 'vs/platform/workspaces/common/workspaces';
47
import { getMachineId } from 'vs/base/node/id';
48 49 50
import { Win32UpdateService } from 'vs/platform/update/electron-main/updateService.win32';
import { LinuxUpdateService } from 'vs/platform/update/electron-main/updateService.linux';
import { DarwinUpdateService } from 'vs/platform/update/electron-main/updateService.darwin';
51
import { IIssueService } from 'vs/platform/issue/common/issue';
J
Joao Moreno 已提交
52
import { IssueChannel } from 'vs/platform/issue/node/issueIpc';
P
Pine Wu 已提交
53
import { IssueService } from 'vs/platform/issue/electron-main/issueService';
J
Joao Moreno 已提交
54
import { LogLevelSetterChannel } from 'vs/platform/log/node/logIpc';
55
import { setUnexpectedErrorHandler, onUnexpectedError } from 'vs/base/common/errors';
J
Joao Moreno 已提交
56
import { ElectronURLListener } from 'vs/platform/url/electron-main/electronUrlListener';
J
Joao Moreno 已提交
57
import { serve as serveDriver } from 'vs/platform/driver/electron-main/driver';
A
Alex Dima 已提交
58
import { connectRemoteAgentManagement, ManagementPersistentConnection, IConnectionOptions } from 'vs/platform/remote/common/remoteAgentConnection';
59 60
import { IMenubarService } from 'vs/platform/menubar/common/menubar';
import { MenubarService } from 'vs/platform/menubar/electron-main/menubarService';
J
Joao Moreno 已提交
61
import { MenubarChannel } from 'vs/platform/menubar/node/menubarIpc';
M
Martin Aeschlimann 已提交
62
import { hasArgs } from 'vs/platform/environment/node/argv';
63
import { RunOnceScheduler } from 'vs/base/common/async';
64
import { registerContextMenuListener } from 'vs/base/parts/contextmenu/electron-main/contextmenu';
B
Benjamin Pasero 已提交
65
import { homedir } from 'os';
66
import { join, sep, dirname } from 'vs/base/common/path';
B
Benjamin Pasero 已提交
67
import { localize } from 'vs/nls';
B
Benjamin Pasero 已提交
68
import { Schemas } from 'vs/base/common/network';
A
Alex Dima 已提交
69
import { REMOTE_FILE_SYSTEM_CHANNEL_NAME } from 'vs/platform/remote/common/remoteAgentFileSystemChannel';
A
Tweaks  
Alex Dima 已提交
70
import { ResolvedAuthority } from 'vs/platform/remote/common/remoteAuthorityResolver';
J
Joao Moreno 已提交
71
import { SnapUpdateService } from 'vs/platform/update/electron-main/updateService.snap';
B
wip  
Benjamin Pasero 已提交
72 73
import { IStorageMainService, StorageMainService } from 'vs/platform/storage/node/storageMainService';
import { GlobalStorageDatabaseChannel } from 'vs/platform/storage/node/storageIpc';
74
import { startsWith } from 'vs/base/common/strings';
75 76 77 78 79
import { BackupMainService } from 'vs/platform/backup/electron-main/backupMainService';
import { IBackupMainService } from 'vs/platform/backup/common/backup';
import { HistoryMainService } from 'vs/platform/history/electron-main/historyMainService';
import { URLService } from 'vs/platform/url/common/urlService';
import { WorkspacesMainService } from 'vs/platform/workspaces/electron-main/workspacesMainService';
80
import { RemoteAgentConnectionContext } from 'vs/platform/remote/common/remoteAgentEnvironment';
A
Alex Dima 已提交
81
import { nodeWebSocketFactory } from 'vs/platform/remote/node/nodeWebSocketFactory';
A
Alex Dima 已提交
82
import { VSBuffer } from 'vs/base/common/buffer';
83 84
import { statSync, utimes } from 'fs';
import { promisify } from 'util';
85

86
export class CodeApplication extends Disposable {
B
Benjamin Pasero 已提交
87

88
	private static readonly MACHINE_ID_KEY = 'telemetry.machineId';
B
Benjamin Pasero 已提交
89

90 91
	private static APP_ICON_REFRESH_KEY = 'macOSAppIconRefresh7';

92
	private windowsMainService: IWindowsMainService | undefined;
93 94

	constructor(
95 96
		private readonly mainIpcServer: Server,
		private readonly userEnv: IProcessEnvironment,
97 98 99 100 101 102
		@IInstantiationService private readonly instantiationService: IInstantiationService,
		@ILogService private readonly logService: ILogService,
		@IEnvironmentService private readonly environmentService: IEnvironmentService,
		@ILifecycleService private readonly lifecycleService: ILifecycleService,
		@IConfigurationService private readonly configurationService: ConfigurationService,
		@IStateService private readonly stateService: IStateService
103
	) {
104 105
		super();

106 107 108 109 110 111
		this.registerListeners();
	}

	private registerListeners(): void {

		// We handle uncaught exceptions here to prevent electron from opening a dialog to the user
112
		setUnexpectedErrorHandler(err => this.onUnexpectedError(err));
B
Benjamin Pasero 已提交
113
		process.on('uncaughtException', err => this.onUnexpectedError(err));
114
		process.on('unhandledRejection', (reason: unknown) => onUnexpectedError(reason));
115

B
Benjamin Pasero 已提交
116 117
		// Dispose on shutdown
		this.lifecycleService.onWillShutdown(() => this.dispose());
118

119 120 121
		// Contextmenu via IPC support
		registerContextMenuListener();

122 123 124 125 126 127 128
		app.on('accessibility-support-changed', (event: Event, accessibilitySupportEnabled: boolean) => {
			if (this.windowsMainService) {
				this.windowsMainService.sendToAll('vscode:accessibilitySupportChanged', accessibilitySupportEnabled);
			}
		});

		app.on('activate', (event: Event, hasVisibleWindows: boolean) => {
J
Joao Moreno 已提交
129
			this.logService.trace('App#activate');
130 131 132 133 134 135 136

			// Mac only event: open new window when we get activated
			if (!hasVisibleWindows && this.windowsMainService) {
				this.windowsMainService.openNewWindow(OpenContext.DOCK);
			}
		});

137 138
		// Security related measures (https://electronjs.org/docs/tutorial/security)
		// DO NOT CHANGE without consulting the documentation
139
		app.on('web-contents-created', (event: Electron.Event, contents) => {
140
			contents.on('will-attach-webview', (event: Electron.Event, webPreferences, params) => {
141

142 143 144 145 146 147 148 149 150
				const isValidWebviewSource = (source: string): boolean => {
					if (!source) {
						return false;
					}

					if (source === 'data:text/html;charset=utf-8,%3C%21DOCTYPE%20html%3E%0D%0A%3Chtml%20lang%3D%22en%22%20style%3D%22width%3A%20100%25%3B%20height%3A%20100%25%22%3E%0D%0A%3Chead%3E%0D%0A%09%3Ctitle%3EVirtual%20Document%3C%2Ftitle%3E%0D%0A%3C%2Fhead%3E%0D%0A%3Cbody%20style%3D%22margin%3A%200%3B%20overflow%3A%20hidden%3B%20width%3A%20100%25%3B%20height%3A%20100%25%22%3E%0D%0A%3C%2Fbody%3E%0D%0A%3C%2Fhtml%3E') {
						return true;
					}

151
					const srcUri = URI.parse(source).fsPath.toLowerCase();
152 153
					const rootUri = URI.file(this.environmentService.appRoot).fsPath.toLowerCase();

154
					return startsWith(srcUri, rootUri + sep);
155 156
				};

157
				// Ensure defaults
M
Matt Bierner 已提交
158 159 160 161
				delete webPreferences.preload;
				webPreferences.nodeIntegration = false;

				// Verify URLs being loaded
162
				if (isValidWebviewSource(params.src) && isValidWebviewSource(webPreferences.preloadURL)) {
M
Matt Bierner 已提交
163 164
					return;
				}
M
Matt Bierner 已提交
165

166 167
				delete webPreferences.preloadUrl;

M
Matt Bierner 已提交
168
				// Otherwise prevent loading
B
Benjamin Pasero 已提交
169
				this.logService.error('webContents#web-contents-created: Prevented webview attach');
170

M
Matt Bierner 已提交
171 172 173 174
				event.preventDefault();
			});

			contents.on('will-navigate', event => {
B
Benjamin Pasero 已提交
175
				this.logService.error('webContents#will-navigate: Prevented webcontent navigation');
176

M
Matt Bierner 已提交
177 178
				event.preventDefault();
			});
179 180 181 182 183 184

			contents.on('new-window', (event: Event, url: string) => {
				event.preventDefault(); // prevent code that wants to open links

				shell.openExternal(url);
			});
M
Matt Bierner 已提交
185 186
		});

187
		let macOpenFileURIs: IURIToOpen[] = [];
188
		let runningTimeout: NodeJS.Timeout | null = null;
189
		app.on('open-file', (event: Event, path: string) => {
J
Joao Moreno 已提交
190
			this.logService.trace('App#open-file: ', path);
191 192 193
			event.preventDefault();

			// Keep in array because more might come!
194
			macOpenFileURIs.push(this.getURIToOpenFromPathSync(path));
195 196 197 198 199 200 201 202 203 204 205 206 207

			// Clear previous handler if any
			if (runningTimeout !== null) {
				clearTimeout(runningTimeout);
				runningTimeout = null;
			}

			// Handle paths delayed in case more are coming!
			runningTimeout = setTimeout(() => {
				if (this.windowsMainService) {
					this.windowsMainService.open({
						context: OpenContext.DOCK /* can also be opening from finder while app is running */,
						cli: this.environmentService.args,
S
Sandeep Somavarapu 已提交
208
						urisToOpen: macOpenFileURIs,
209 210
						preferNewWindow: true /* dropping on the dock or opening from finder prefers to open in a new window */
					});
211

212
					macOpenFileURIs = [];
213 214 215 216 217
					runningTimeout = null;
				}
			}, 100);
		});

218
		app.on('new-window-for-tab', () => {
219 220 221
			if (this.windowsMainService) {
				this.windowsMainService.openNewWindow(OpenContext.DESKTOP); //macOS native tab "+" button
			}
222 223
		});

224
		ipc.on('vscode:exit', (event: Event, code: number) => {
J
Joao Moreno 已提交
225
			this.logService.trace('IPC#vscode:exit', code);
226 227 228 229 230

			this.dispose();
			this.lifecycleService.kill(code);
		});

231
		ipc.on('vscode:fetchShellEnv', async (event: Event) => {
232
			const webContents = event.sender;
233 234 235

			try {
				const shellEnv = await getShellEnvironment(this.logService);
J
Johannes Rieken 已提交
236 237 238
				if (!webContents.isDestroyed()) {
					webContents.send('vscode:acceptShellEnv', shellEnv);
				}
239
			} catch (error) {
J
Johannes Rieken 已提交
240 241 242
				if (!webContents.isDestroyed()) {
					webContents.send('vscode:acceptShellEnv', {});
				}
B
Benjamin Pasero 已提交
243

244 245
				this.logService.error('Error fetching shell env', error);
			}
246
		});
247

248 249
		ipc.on('vscode:extensionHostDebug', (_: Event, windowId: number, broadcast: any) => {
			if (this.windowsMainService) {
250
				this.windowsMainService.sendToAll('vscode:extensionHostDebug', broadcast, [windowId]); // Send to all windows (except sender window)
251 252 253
			}
		});

254 255
		ipc.on('vscode:toggleDevTools', (event: Event) => event.sender.toggleDevTools());
		ipc.on('vscode:openDevTools', (event: Event) => event.sender.openDevTools());
B
Benjamin Pasero 已提交
256

257
		ipc.on('vscode:reloadWindow', (event: Event) => event.sender.reload());
258

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
		// After waking up from sleep  (after window opened)
		(async () => {
			await this.lifecycleService.when(LifecycleMainPhase.AfterWindowOpen);

			powerMonitor.on('resume', () => {
				if (this.windowsMainService) {
					this.windowsMainService.sendToAll('vscode:osResume', undefined);
				}
			});
		})();

		// Keyboard layout changes (after window opened)
		(async () => {
			await this.lifecycleService.when(LifecycleMainPhase.AfterWindowOpen);

			const nativeKeymap = await import('native-keymap');
			nativeKeymap.onDidChangeKeyboardLayout(() => {
				if (this.windowsMainService) {
					this.windowsMainService.sendToAll('vscode:keyboardLayoutChanged', false);
				}
			});
		})();
281 282
	}

B
Benjamin Pasero 已提交
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
	private onUnexpectedError(err: Error): void {
		if (err) {

			// take only the message and stack property
			const friendlyError = {
				message: err.message,
				stack: err.stack
			};

			// handle on client side
			if (this.windowsMainService) {
				this.windowsMainService.sendToFocused('vscode:reportError', JSON.stringify(friendlyError));
			}
		}

		this.logService.error(`[uncaught exception in main]: ${err}`);
		if (err.stack) {
			this.logService.error(err.stack);
		}
	}

304
	async startup(): Promise<void> {
J
Joao Moreno 已提交
305 306 307
		this.logService.debug('Starting VS Code');
		this.logService.debug(`from: ${this.environmentService.appRoot}`);
		this.logService.debug('args:', this.environmentService.args);
308

309 310 311 312
		// Make sure we associate the program with the app user model id
		// This will help Windows to associate the running program with
		// any shortcut that is pinned to the taskbar and prevent showing
		// two icons in the taskbar for the same app.
313
		if (isWindows && product.win32AppUserModelId) {
314 315
			app.setAppUserModelId(product.win32AppUserModelId);
		}
316

317 318 319 320 321 322 323
		// Fix native tabs on macOS 10.13
		// macOS enables a compatibility patch for any bundle ID beginning with
		// "com.microsoft.", which breaks native tabs for VS Code when using this
		// identifier (from the official build).
		// Explicitly opt out of the patch here before creating any windows.
		// See: https://github.com/Microsoft/vscode/issues/35361#issuecomment-399794085
		try {
324
			if (isMacintosh && this.configurationService.getValue<boolean>('window.nativeTabs') === true && !systemPreferences.getUserDefault('NSUseImprovedLayoutPass', 'boolean')) {
325
				systemPreferences.setUserDefault('NSUseImprovedLayoutPass', 'boolean', true as any);
326 327 328 329 330
			}
		} catch (error) {
			this.logService.error(error);
		}

331
		// Create Electron IPC Server
332
		const electronIpcServer = new ElectronIPCServer();
333

334 335 336 337
		// Resolve unique machine ID
		this.logService.trace('Resolving machine identifier...');
		const machineId = await this.resolveMachineId();
		this.logService.trace(`Resolved machine identifier: ${machineId}`);
338

339 340 341 342 343 344 345 346 347 348
		// Spawn shared process after the first window has opened and 3s have passed
		const sharedProcess = this.instantiationService.createInstance(SharedProcess, machineId, this.userEnv);
		const sharedProcessClient = sharedProcess.whenReady().then(() => connect(this.environmentService.sharedIPCHandle, 'main'));
		this.lifecycleService.when(LifecycleMainPhase.AfterWindowOpen).then(() => {
			this._register(new RunOnceScheduler(async () => {
				const userEnv = await getShellEnvironment(this.logService);

				sharedProcess.spawn(userEnv);
			}, 3000)).schedule();
		});
349

350
		// Services
351
		const appInstantiationService = await this.createServices(machineId, sharedProcess, sharedProcessClient);
352

353 354 355
		// Create driver
		if (this.environmentService.driverHandle) {
			(async () => {
356
				const server = await serveDriver(electronIpcServer, this.environmentService.driverHandle!, this.environmentService, appInstantiationService);
357

358 359 360 361
				this.logService.info('Driver started at:', this.environmentService.driverHandle);
				this._register(server);
			})();
		}
362

363 364 365
		// Setup Auth Handler
		const authHandler = appInstantiationService.createInstance(ProxyAuthHandler);
		this._register(authHandler);
B
Benjamin Pasero 已提交
366

367
		// Open Windows
368
		const windows = appInstantiationService.invokeFunction(accessor => this.openFirstWindow(accessor, electronIpcServer, sharedProcessClient));
B
Benjamin Pasero 已提交
369

370
		// Post Open Windows Tasks
371
		this.afterWindowOpen();
B
Benjamin Pasero 已提交
372

373 374 375
		// Tracing: Stop tracing after windows are ready if enabled
		if (this.environmentService.args.trace) {
			this.stopTracingEventually(windows);
B
Benjamin Pasero 已提交
376 377 378
		}
	}

379
	private async resolveMachineId(): Promise<string> {
B
Benjamin Pasero 已提交
380

381 382 383 384 385
		// We cache the machineId for faster lookups on startup
		// and resolve it only once initially if not cached
		let machineId = this.stateService.getItem<string>(CodeApplication.MACHINE_ID_KEY);
		if (!machineId) {
			machineId = await getMachineId();
B
Benjamin Pasero 已提交
386

387 388
			this.stateService.setItem(CodeApplication.MACHINE_ID_KEY, machineId);
		}
389 390

		return machineId;
391 392
	}

393 394
	private async createServices(machineId: string, sharedProcess: SharedProcess, sharedProcessClient: Promise<Client<string>>): Promise<IInstantiationService> {
		const services = new ServiceCollection();
395

396 397 398 399
		switch (process.platform) {
			case 'win32':
				services.set(IUpdateService, new SyncDescriptor(Win32UpdateService));
				break;
400

401 402 403
			case 'linux':
				if (process.env.SNAP && process.env.SNAP_REVISION) {
					services.set(IUpdateService, new SyncDescriptor(SnapUpdateService, [process.env.SNAP, process.env.SNAP_REVISION]));
404
				} else {
405
					services.set(IUpdateService, new SyncDescriptor(LinuxUpdateService));
B
Benjamin Pasero 已提交
406
				}
407
				break;
408

409 410 411
			case 'darwin':
				services.set(IUpdateService, new SyncDescriptor(DarwinUpdateService));
				break;
412 413
		}

414 415
		services.set(IWindowsMainService, new SyncDescriptor(WindowsManager, [machineId, this.userEnv]));
		services.set(IWindowsService, new SyncDescriptor(WindowsService, [sharedProcess]));
416
		services.set(ILaunchService, new SyncDescriptor(LaunchService));
417
		services.set(IIssueService, new SyncDescriptor(IssueService, [machineId, this.userEnv]));
418
		services.set(IMenubarService, new SyncDescriptor(MenubarService));
419 420 421 422 423 424 425 426

		const storageMainService = new StorageMainService(this.logService, this.environmentService);
		services.set(IStorageMainService, storageMainService);
		this.lifecycleService.onWillShutdown(e => e.join(storageMainService.close()));

		const backupMainService = new BackupMainService(this.environmentService, this.configurationService, this.logService);
		services.set(IBackupMainService, backupMainService);

427 428 429
		services.set(IHistoryMainService, new SyncDescriptor(HistoryMainService));
		services.set(IURLService, new SyncDescriptor(URLService));
		services.set(IWorkspacesMainService, new SyncDescriptor(WorkspacesMainService));
430

431
		// Telemetry
432
		if (!this.environmentService.isExtensionDevelopment && !this.environmentService.args['disable-telemetry'] && !!product.enableTelemetry) {
433
			const channel = getDelayedChannel(sharedProcessClient.then(client => client.getChannel('telemetryAppender')));
434
			const appender = combinedAppender(new TelemetryAppenderClient(channel), new LogAppender(this.logService));
435
			const commonProperties = resolveCommonProperties(product.commit, pkg.version, machineId, this.environmentService.installSourcePath);
436 437
			const piiPaths = [this.environmentService.appRoot, this.environmentService.extensionsPath];
			const config: ITelemetryServiceConfig = { appender, commonProperties, piiPaths };
438

439
			services.set(ITelemetryService, new SyncDescriptor(TelemetryService, [config]));
440 441 442 443
		} else {
			services.set(ITelemetryService, NullTelemetryService);
		}

444
		// Init services that require it
445
		await backupMainService.initialize();
446

447
		return this.instantiationService.createChild(services);
448 449
	}

450 451
	private stopTracingEventually(windows: ICodeWindow[]): void {
		this.logService.info(`Tracing: waiting for windows to get ready...`);
452

453 454 455 456 457
		let recordingStopped = false;
		const stopRecording = (timeout: boolean) => {
			if (recordingStopped) {
				return;
			}
B
wip  
Benjamin Pasero 已提交
458

459
			recordingStopped = true; // only once
460

461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
			contentTracing.stopRecording(join(homedir(), `${product.applicationName}-${Math.random().toString(16).slice(-4)}.trace.txt`), path => {
				if (!timeout) {
					if (this.windowsMainService) {
						this.windowsMainService.showMessageBox({
							type: 'info',
							message: localize('trace.message', "Successfully created trace."),
							detail: localize('trace.detail', "Please create an issue and manually attach the following file:\n{0}", path),
							buttons: [localize('trace.ok', "Ok")]
						}, this.windowsMainService.getLastActiveWindow());
					}
				} else {
					this.logService.info(`Tracing: data recorded (after 30s timeout) to ${path}`);
				}
			});
		};
476

477 478 479 480 481 482 483 484
		// Wait up to 30s before creating the trace anyways
		const timeoutHandle = setTimeout(() => stopRecording(true), 30000);

		// Wait for all windows to get ready and stop tracing then
		Promise.all(windows.map(window => window.ready())).then(() => {
			clearTimeout(timeoutHandle);
			stopRecording(false);
		});
485 486
	}

487
	private openFirstWindow(accessor: ServicesAccessor, electronIpcServer: ElectronIPCServer, sharedProcessClient: Promise<Client<string>>): ICodeWindow[] {
488 489 490 491 492 493 494 495 496

		// Register more Main IPC services
		const launchService = accessor.get(ILaunchService);
		const launchChannel = new LaunchChannel(launchService);
		this.mainIpcServer.registerChannel('launch', launchChannel);

		// Register more Electron IPC services
		const updateService = accessor.get(IUpdateService);
		const updateChannel = new UpdateChannel(updateService);
497
		electronIpcServer.registerChannel('update', updateChannel);
498

499 500
		const issueService = accessor.get(IIssueService);
		const issueChannel = new IssueChannel(issueService);
501
		electronIpcServer.registerChannel('issue', issueChannel);
502

B
Benjamin Pasero 已提交
503
		const workspacesService = accessor.get(IWorkspacesMainService);
504 505
		const workspacesChannel = new WorkspacesChannel(workspacesService);
		electronIpcServer.registerChannel('workspaces', workspacesChannel);
B
Benjamin Pasero 已提交
506

507 508
		const windowsService = accessor.get(IWindowsService);
		const windowsChannel = new WindowsChannel(windowsService);
509 510
		electronIpcServer.registerChannel('windows', windowsChannel);
		sharedProcessClient.then(client => client.registerChannel('windows', windowsChannel));
511

512 513
		const menubarService = accessor.get(IMenubarService);
		const menubarChannel = new MenubarChannel(menubarService);
514
		electronIpcServer.registerChannel('menubar', menubarChannel);
515

J
Joao Moreno 已提交
516 517
		const urlService = accessor.get(IURLService);
		const urlChannel = new URLServiceChannel(urlService);
518
		electronIpcServer.registerChannel('url', urlChannel);
J
Joao Moreno 已提交
519

520
		const storageMainService = accessor.get(IStorageMainService);
521
		const storageChannel = this._register(new GlobalStorageDatabaseChannel(this.logService, storageMainService as StorageMainService));
522
		electronIpcServer.registerChannel('storage', storageChannel);
B
wip  
Benjamin Pasero 已提交
523

S
Sandeep Somavarapu 已提交
524
		// Log level management
525
		const logLevelChannel = new LogLevelSetterChannel(accessor.get(ILogService));
526 527
		electronIpcServer.registerChannel('loglevel', logLevelChannel);
		sharedProcessClient.then(client => client.registerChannel('loglevel', logLevelChannel));
S
Sandeep Somavarapu 已提交
528

529 530
		// Signal phase: ready (services set)
		this.lifecycleService.phase = LifecycleMainPhase.Ready;
531 532

		// Propagate to clients
533
		const windowsMainService = this.windowsMainService = accessor.get(IWindowsMainService); // TODO@Joao: unfold this
J
Joao Moreno 已提交
534

J
Joao Moreno 已提交
535
		// Create a URL handler which forwards to the last active window
J
Joao Moreno 已提交
536
		const activeWindowManager = new ActiveWindowManager(windowsService);
J
Joao Moreno 已提交
537
		const activeWindowRouter = new StaticRouter(ctx => activeWindowManager.getActiveClientId().then(id => ctx === id));
538
		const urlHandlerChannel = electronIpcServer.getChannel('urlHandler', activeWindowRouter);
J
Joao Moreno 已提交
539
		const multiplexURLHandler = new URLHandlerChannelClient(urlHandlerChannel);
J
Joao Moreno 已提交
540

541 542
		// On Mac, Code can be running without any open windows, so we must create a window to handle urls,
		// if there is none
543
		if (isMacintosh) {
544 545 546
			const environmentService = accessor.get(IEnvironmentService);

			urlService.registerHandler({
547
				async handleURL(uri: URI): Promise<boolean> {
548 549 550 551
					if (windowsMainService.getWindowCount() === 0) {
						const cli = { ...environmentService.args, goto: true };
						const [window] = windowsMainService.open({ context: OpenContext.API, cli, forceEmpty: true });

552 553 554
						await window.ready();

						return urlService.open(uri);
555 556
					}

557
					return false;
558 559 560 561
				}
			});
		}

562
		// Register the multiple URL handler
J
Joao Moreno 已提交
563 564
		urlService.registerHandler(multiplexURLHandler);

J
Joao Moreno 已提交
565
		// Watch Electron URLs and forward them to the UrlService
566
		const args = this.environmentService.args;
J
Joao Moreno 已提交
567
		const urls = args['open-url'] ? args._urls : [];
568
		const urlListener = new ElectronURLListener(urls || [], urlService, windowsMainService);
569
		this._register(urlListener);
J
Joao Moreno 已提交
570

571
		// Open our first window
572
		const macOpenFiles: string[] = (<any>global).macOpenFiles;
573
		const context = !!process.env['VSCODE_CLI'] ? OpenContext.CLI : OpenContext.DESKTOP;
M
Martin Aeschlimann 已提交
574 575 576
		const hasCliArgs = hasArgs(args._);
		const hasFolderURIs = hasArgs(args['folder-uri']);
		const hasFileURIs = hasArgs(args['file-uri']);
577
		const noRecentEntry = args['skip-add-to-recently-opened'] === true;
M
Martin Aeschlimann 已提交
578
		const waitMarkerFileURI = args.wait && args.waitMarkerFilePath ? URI.file(args.waitMarkerFilePath) : undefined;
579

580
		// new window if "-n" was used without paths
M
Martin Aeschlimann 已提交
581
		if (args['new-window'] && !hasCliArgs && !hasFolderURIs && !hasFileURIs) {
582
			return windowsMainService.open({
M
Martin Aeschlimann 已提交
583 584 585 586 587 588 589 590
				context,
				cli: args,
				forceNewWindow: true,
				forceEmpty: true,
				noRecentEntry,
				waitMarkerFileURI,
				initialStartup: true
			});
591
		}
B
Benjamin Pasero 已提交
592

593
		// mac: open-file event received on startup
B
Benjamin Pasero 已提交
594
		if (macOpenFiles && macOpenFiles.length && !hasCliArgs && !hasFolderURIs && !hasFileURIs) {
595
			return windowsMainService.open({
M
Martin Aeschlimann 已提交
596 597
				context: OpenContext.DOCK,
				cli: args,
598
				urisToOpen: macOpenFiles.map(file => this.getURIToOpenFromPathSync(file)),
M
Martin Aeschlimann 已提交
599 600 601 602
				noRecentEntry,
				waitMarkerFileURI,
				initialStartup: true
			});
B
Benjamin Pasero 已提交
603 604
		}

M
Martin Aeschlimann 已提交
605
		// default: read paths from cli
606
		return windowsMainService.open({
M
Martin Aeschlimann 已提交
607 608 609 610 611 612 613 614
			context,
			cli: args,
			forceNewWindow: args['new-window'] || (!hasCliArgs && args['unity-launch']),
			diffMode: args.diff,
			noRecentEntry,
			waitMarkerFileURI,
			initialStartup: true
		});
615 616
	}

617 618 619 620 621
	private getURIToOpenFromPathSync(path: string): IURIToOpen {
		try {
			const fileStat = statSync(path);
			if (fileStat.isDirectory()) {
				return { folderUri: URI.file(path) };
622
			}
623

624 625
			if (hasWorkspaceFileExtension(path)) {
				return { workspaceUri: URI.file(path) };
626
			}
627 628
		} catch (error) {
			// ignore errors
629
		}
630

631 632
		return { fileUri: URI.file(path) };
	}
633

634
	private afterWindowOpen(): void {
635

636 637
		// Signal phase: after window open
		this.lifecycleService.phase = LifecycleMainPhase.AfterWindowOpen;
638

639 640
		// Remote Authorities
		this.handleRemoteAuthorities();
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664

		// Helps application icon refresh after an update with new icon is installed (macOS)
		// TODO@Ben remove after a couple of releases
		if (isMacintosh) {
			if (!this.stateService.getItem(CodeApplication.APP_ICON_REFRESH_KEY)) {
				this.stateService.setItem(CodeApplication.APP_ICON_REFRESH_KEY, true);

				// 'exe' => /Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron
				const appPath = dirname(dirname(dirname(app.getPath('exe'))));
				const infoPlistPath = join(appPath, 'Contents', 'Info.plist');
				this.touch(appPath);
				this.touch(infoPlistPath);
			}
		}
	}

	private async touch(path: string): Promise<void> {
		const now = Date.now() / 1000; // the value should be a Unix timestamp in seconds

		try {
			await promisify(utimes)(path, now, now);
		} catch (error) {
			// ignore
		}
665
	}
666 667 668 669

	private handleRemoteAuthorities(): void {
		const connectionPool: Map<string, ActiveConnection> = new Map<string, ActiveConnection>();

A
Alex Dima 已提交
670 671
		const isBuilt = this.environmentService.isBuilt;

672
		class ActiveConnection {
673
			private readonly _authority: string;
A
Alex Dima 已提交
674
			private readonly _connection: Promise<ManagementPersistentConnection>;
675
			private readonly _disposeRunner: RunOnceScheduler;
676 677 678

			constructor(authority: string, host: string, port: number) {
				this._authority = authority;
679

A
Alex Dima 已提交
680
				const options: IConnectionOptions = {
681
					isBuilt,
A
Alex Dima 已提交
682
					commit: product.commit,
A
Alex Dima 已提交
683
					webSocketFactory: nodeWebSocketFactory,
A
Alex Dima 已提交
684 685 686 687 688 689
					addressProvider: {
						getAddress: () => {
							return Promise.resolve({ host, port });
						}
					}
				};
690

A
Alex Dima 已提交
691
				this._connection = connectRemoteAgentManagement(options, authority, `main`);
692
				this._disposeRunner = new RunOnceScheduler(() => this.dispose(), 5000);
693 694
			}

695
			dispose(): void {
696 697
				this._disposeRunner.dispose();
				connectionPool.delete(this._authority);
698
				this._connection.then(connection => connection.dispose());
699 700
			}

A
Alex Dima 已提交
701
			async getClient(): Promise<Client<RemoteAgentConnectionContext>> {
702
				this._disposeRunner.schedule();
A
Alex Dima 已提交
703
				const connection = await this._connection;
704

A
Alex Dima 已提交
705
				return connection.client;
706 707 708 709
			}
		}

		const resolvedAuthorities = new Map<string, ResolvedAuthority>();
710
		ipc.on('vscode:remoteAuthorityResolved', (event: Electron.Event, data: ResolvedAuthority) => {
711
			this.logService.info('Received resolved authority', data.authority);
712

713
			resolvedAuthorities.set(data.authority, data);
714

715 716
			// Make sure to close and remove any existing connections
			if (connectionPool.has(data.authority)) {
A
Alex Dima 已提交
717
				connectionPool.get(data.authority)!.dispose();
718
			}
719 720 721
		});

		const resolveAuthority = (authority: string): ResolvedAuthority | null => {
722
			this.logService.info('Resolving authority', authority);
723

724 725
			if (authority.indexOf('+') >= 0) {
				if (resolvedAuthorities.has(authority)) {
M
Matt Bierner 已提交
726
					return withUndefinedAsNull(resolvedAuthorities.get(authority));
727
				}
728

729
				this.logService.info('Didnot find resolved authority for', authority);
730

731 732 733 734
				return null;
			} else {
				const [host, strPort] = authority.split(':');
				const port = parseInt(strPort, 10);
735

736
				return { authority, host, port };
737 738 739
			}
		};

B
Benjamin Pasero 已提交
740
		protocol.registerBufferProtocol(Schemas.vscodeRemote, async (request, callback) => {
741
			if (request.method !== 'GET') {
742
				return callback(undefined);
743
			}
744

745 746
			const uri = URI.parse(request.url);

747
			let activeConnection: ActiveConnection | undefined;
748 749 750
			if (connectionPool.has(uri.authority)) {
				activeConnection = connectionPool.get(uri.authority);
			} else {
751
				const resolvedAuthority = resolveAuthority(uri.authority);
752
				if (!resolvedAuthority) {
753
					callback(undefined);
754 755
					return;
				}
756

757 758 759
				activeConnection = new ActiveConnection(uri.authority, resolvedAuthority.host, resolvedAuthority.port);
				connectionPool.set(uri.authority, activeConnection);
			}
760

761
			try {
762
				const rawClient = await activeConnection!.getClient();
763 764 765 766
				if (connectionPool.has(uri.authority)) { // not disposed in the meantime
					const channel = rawClient.getChannel(REMOTE_FILE_SYSTEM_CHANNEL_NAME);

					// TODO@alex don't use call directly, wrap it around a `RemoteExtensionsFileSystemProvider`
A
Alex Dima 已提交
767 768
					const fileContents = await channel.call<VSBuffer>('readFile', [uri]);
					callback(<Buffer>fileContents.buffer);
769
				} else {
770
					callback(undefined);
771 772
				}
			} catch (err) {
773
				onUnexpectedError(err);
774
				callback(undefined);
775 776 777
			}
		});
	}
778
}