environmentService.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import { Schemas } from 'vs/base/common/network';
import { ExportData } from 'vs/base/common/performance';
import { IProcessEnvironment } from 'vs/base/common/platform';
import { joinPath } from 'vs/base/common/resources';
import { URI } from 'vs/base/common/uri';
import { generateUuid } from 'vs/base/common/uuid';
import { BACKUPS, IDebugParams, IExtensionHostDebugParams } from 'vs/platform/environment/common/environment';
import { LogLevel } from 'vs/platform/log/common/log';
import { IPath, IPathsToWaitFor, IWindowConfiguration } from 'vs/platform/windows/common/windows';
import { ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
import { IWorkbenchConstructionOptions } from 'vs/workbench/workbench.web.api';
import product from 'vs/platform/product/common/product';
import { serializableToMap } from 'vs/base/common/map';
import { memoize } from 'vs/base/common/decorators';

export class BrowserWindowConfiguration implements IWindowConfiguration {

	constructor(private readonly options: IBrowserWorkbenchEnvironemntConstructionOptions) { }

	//#region PROPERLY CONFIGURED

	get remoteAuthority(): string | undefined { return this.options.remoteAuthority; }

	//#endregion


	//#region TODO@ben TO BE DONE

	_!: any[];

	readonly machineId = generateUuid();
	windowId!: number;
	logLevel!: LogLevel;

	mainPid!: number;

	appRoot!: string;
	execPath!: string;
	isInitialStartup?: boolean;

	userEnv!: IProcessEnvironment;
	nodeCachedDataDir?: string;

	backupPath?: string;
	backupWorkspaceResource?: URI;

	workspace?: IWorkspaceIdentifier;
	folderUri?: ISingleFolderWorkspaceIdentifier;

	connectionToken?: string;

	zoomLevel?: number;
	fullscreen?: boolean;
	maximized?: boolean;
	highContrast?: boolean;
	frameless?: boolean;
	accessibilitySupport?: boolean;
	partsSplashPath?: string;

	perfStartTime?: number;
	perfAppReady?: number;
	perfWindowLoadTime?: number;
	perfEntries!: ExportData;

	filesToOpenOrCreate?: IPath[];
	filesToDiff?: IPath[];
	filesToWait?: IPathsToWaitFor;
	termProgram?: string;

	//#endregion
}

interface IBrowserWorkbenchEnvironemntConstructionOptions extends IWorkbenchConstructionOptions {
	workspaceId: string;
	logsPath: URI;
}

export class BrowserWorkbenchEnvironmentService implements IWorkbenchEnvironmentService {

	_serviceBrand: undefined;

	//#region PROPERLY CONFIGURED

	@memoize
	get logsPath(): string { return this.options.logsPath.path; }

	@memoize
	get logFile(): URI { return joinPath(this.options.logsPath, 'window.log'); }

	@memoize
	get userRoamingDataHome(): URI { return URI.file('/User').with({ scheme: Schemas.userData }); }

	@memoize
	get settingsResource(): URI { return joinPath(this.userRoamingDataHome, 'settings.json'); }

	@memoize
	get settingsSyncPreviewResource(): URI { return joinPath(this.userRoamingDataHome, '.settings.json'); }

	@memoize
	get userDataSyncLogResource(): URI { return joinPath(this.options.logsPath, 'userDataSync.log'); }

	@memoize
	get keybindingsResource(): URI { return joinPath(this.userRoamingDataHome, 'keybindings.json'); }

	get keyboardLayoutResource(): URI { return joinPath(this.userRoamingDataHome, 'keyboardLayout.json'); }

	//#endregion


	//#region TODO@ben TO BE DONE

	private _configuration: IWindowConfiguration | undefined = undefined;
	get configuration(): IWindowConfiguration {
		if (!this._configuration) {
			this._configuration = new BrowserWindowConfiguration(this.options);
		}

		return this._configuration;
	}

	readonly args = { _: [] };
	readonly appRoot = '/web/';

	// TODO@Ben get out of product.json?!
	readonly appNameLong = 'Visual Studio Code - Web';

	untitledWorkspacesHome: URI;
	extensionTestsLocationURI?: URI;

	execPath!: string;
	cliPath!: string;
	userHome!: string;
	userDataPath!: string;
	appQuality?: string;
	appSettingsHome!: URI;
	argvResource: URI;
	machineSettingsHome!: URI;
	machineSettingsResource!: URI;
	globalStorageHome!: string;
	workspaceStorageHome!: string;
	backupHome: URI;
	backupWorkspacesPath!: string;
	workspacesHome!: string;
	isExtensionDevelopment!: boolean;
	disableExtensions!: boolean | string[];
	builtinExtensionsPath!: string;
	extensionsPath?: string;
	extensionDevelopmentLocationURI?: URI[];
	extensionTestsPath?: string;
	debugExtensionHost: IExtensionHostDebugParams;
	debugSearch!: IDebugParams;
	logExtensionHostCommunication!: boolean;
	isBuilt!: boolean;
	wait!: boolean;
	status!: boolean;
	log?: string;

	verbose!: boolean;
	skipReleaseNotes!: boolean;
	mainIPCHandle!: string;
	sharedIPCHandle!: string;
	nodeCachedDataDir?: string;
	installSourcePath!: string;
	disableUpdates!: boolean;
	disableCrashReporter!: boolean;
	driverHandle?: string;
	driverVerbose!: boolean;
	galleryMachineIdResource?: URI;

	get webviewExternalEndpoint(): string {
		// TODO: get fallback from product.json
		return (this.options.webviewEndpoint || 'https://{{uuid}}.vscode-webview-test.com/{{commit}}')
			.replace('{{commit}}', product.commit || 'c58aaab8a1cc22a7139b761166a0d4f37d41e998');
	}

	get webviewResourceRoot(): string {
		return `${this.webviewExternalEndpoint}/vscode-resource/{{resource}}`;
	}

	get webviewCspSource(): string {
		return this.webviewExternalEndpoint
			.replace('{{uuid}}', '*');
	}

	//#endregion

	constructor(readonly options: IBrowserWorkbenchEnvironemntConstructionOptions) {
		this.argvResource = joinPath(this.userRoamingDataHome, 'argv.json');
		this.backupHome = joinPath(this.userRoamingDataHome, BACKUPS);
		this.untitledWorkspacesHome = joinPath(this.userRoamingDataHome, 'Workspaces');
		this.configuration.backupWorkspaceResource = joinPath(this.backupHome, options.workspaceId);
		this.configuration.connectionToken = options.connectionToken || getCookieValue('vscode-tkn');

		this.debugExtensionHost = {
			port: null,
			break: false
		};

		// Fill in selected extra environmental properties
		if (options.workspaceProvider && Array.isArray(options.workspaceProvider.payload)) {
			const environment = serializableToMap(options.workspaceProvider.payload);
			for (const [key, value] of environment) {
				switch (key) {
					case 'extensionDevelopmentPath':
						this.extensionDevelopmentLocationURI = [URI.parse(value)];
						this.isExtensionDevelopment = true;
						break;
					case 'debugId':
						this.debugExtensionHost.debugId = value;
						break;
					case 'inspect-brk-extensions':
						this.debugExtensionHost.port = parseInt(value);
						this.debugExtensionHost.break = false;
						break;
				}
			}
		} else {
			// TODO@Ben remove me once environment is adopted
			if (document && document.location && document.location.search) {
				const map = new Map<string, string>();
				const query = document.location.search.substring(1);
				const vars = query.split('&');
				for (let p of vars) {
					const pair = p.split('=');
					if (pair.length >= 2) {
						map.set(pair[0], decodeURIComponent(pair[1]));
					}
				}

				const edp = map.get('extensionDevelopmentPath');
				if (edp) {
					this.extensionDevelopmentLocationURI = [URI.parse(edp)];
					this.isExtensionDevelopment = true;
				}

				const di = map.get('debugId');
				if (di) {
					this.debugExtensionHost.debugId = di;
				}

				const ibe = map.get('inspect-brk-extensions');
				if (ibe) {
					this.debugExtensionHost.port = parseInt(ibe);
					this.debugExtensionHost.break = false;
				}
			}
		}
	}
}

/**
 * See https://stackoverflow.com/a/25490531
 */
function getCookieValue(name: string): string | undefined {
	const m = document.cookie.match('(^|[^;]+)\\s*' + name + '\\s*=\\s*([^;]+)');
	return m ? m.pop() : undefined;
}