Offline mode

src/vs/code/electron-main/logUploader.ts

@@ -17,6 +17,8 @@ import product from 'vs/platform/node/product';
 import { IRequestService } from 'vs/platform/request/node/request';
 import { IRequestContext } from 'vs/base/node/request';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { offlineModeSetting, unSupportedInOfflineModeMsg } from 'vs/platform/actions/common/offlineMode';
 
 interface PostResult {
 	readonly blob_id: string;
@@ -36,8 +38,14 @@ class Endpoint {
 export async function uploadLogs(
 	channel: ILaunchChannel,
 	requestService: IRequestService,
-	environmentService: IEnvironmentService
+	environmentService: IEnvironmentService,
+	configurationService: IConfigurationService
 ): Promise<any> {
+	if (configurationService.getValue(offlineModeSetting) === true) {
+		console.error(unSupportedInOfflineModeMsg);
+		return;
+	}
+
 	const endpoint = Endpoint.getFromProduct();
 	if (!endpoint) {
 		console.error(localize('invalidEndpoint', 'Invalid log uploader endpoint'));

src/vs/code/electron-main/main.ts

@@ -111,6 +111,7 @@ function setupIPC(accessor: ServicesAccessor): TPromise<Server> {
 	const logService = accessor.get(ILogService);
 	const environmentService = accessor.get(IEnvironmentService);
 	const requestService = accessor.get(IRequestService);
+	const configurationService = accessor.get(IConfigurationService);
 
 	function allowSetForegroundWindow(service: LaunchChannelClient): TPromise<void> {
 		let promise = TPromise.wrap<void>(void 0);
@@ -204,7 +205,7 @@ function setupIPC(accessor: ServicesAccessor): TPromise<Server> {
 
 					// Log uploader
 					if (typeof environmentService.args['upload-logs'] !== 'undefined') {
-						return uploadLogs(channel, requestService, environmentService)
+						return uploadLogs(channel, requestService, environmentService, configurationService)
 							.then(() => TPromise.wrapError(new ExpectedError()));
 					}
 

src/vs/code/electron-main/menubar.ts

@@ -23,6 +23,7 @@ import { IHistoryMainService } from 'vs/platform/history/common/history';
 import { IWorkspaceIdentifier, getWorkspaceLabel, ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
 import { IMenubarData, IMenubarMenuItemAction, IMenubarMenuItemSeparator } from 'vs/platform/menubar/common/menubar';
 import URI from 'vs/base/common/uri';
+import { offlineModeSetting } from 'vs/platform/actions/common/offlineMode';
 
 // interface IExtensionViewlet {
 // 	id: string;
@@ -581,6 +582,13 @@ export class Menubar {
 	}
 
 	private getUpdateMenuItems(): Electron.MenuItem[] {
+		if (this.configurationService.getValue(offlineModeSetting) === true) {
+			return [new MenuItem({
+				label: nls.localize('miCheckForUpdates', "Check for Updates..."), click: () => {
+					this.runActionInRenderer('workbench.action.notifyUnsupportedFeatureInOfflineMode');
+				}
+			})];
+		}
 		const state = this.updateService.state;
 
 		switch (state.type) {

src/vs/code/electron-main/menus.ts

@@ -24,6 +24,7 @@ import { IWindowsMainService, IWindowsCountChangedEvent } from 'vs/platform/wind
 import { IHistoryMainService } from 'vs/platform/history/common/history';
 import { IWorkspaceIdentifier, getWorkspaceLabel, ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
 import URI from 'vs/base/common/uri';
+import { offlineModeSetting } from 'vs/platform/actions/common/offlineMode';
 
 interface IMenuItemClickHandler {
 	inDevTools: (contents: Electron.WebContents) => void;
@@ -1124,6 +1125,13 @@ export class CodeMenu {
 	}
 
 	private getUpdateMenuItems(): Electron.MenuItem[] {
+		if (this.configurationService.getValue(offlineModeSetting) === true) {
+			return [new MenuItem({
+				label: nls.localize('miCheckForUpdates', "Check for Updates..."), click: () => {
+					this.runActionInRenderer('workbench.action.notifyUnsupportedFeatureInOfflineMode');
+				}
+			})];
+		}
 		const state = this.updateService.state;
 
 		switch (state.type) {

src/vs/platform/actions/common/offlineMode.ts

@@ -0,0 +1,159 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { localize } from 'vs/nls';
+import { Action } from 'vs/base/common/actions';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
+import { MenuRegistry, MenuId } from 'vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import { CommandsRegistry } from 'vs/platform/commands/common/commands';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+
+export const offlineModeSetting = 'workbench.enableOfflineMode';
+export const unSupportedInOfflineModeMsg = localize('offlineModeUnsupportedFeature', "This feature is not supported in offline mode");
+
+export class EnableOfflineMode extends Action {
+	static readonly ID = 'workbench.action.enableOfflineMode';
+	static LABEL = localize('enableOfflineMode', 'Enable Offline Mode');
+
+	private readonly disclaimerStorageKey = 'workbench.offlineMode.disclaimer.dontShowAgain';
+
+	constructor(
+		id: string = EnableOfflineMode.ID,
+		label: string = EnableOfflineMode.LABEL,
+		@IConfigurationService private configurationService: IConfigurationService,
+		@IStorageService private storageService: IStorageService,
+		@INotificationService private notificationService: INotificationService
+	) {
+		super(id, label);
+		this.updateEnabled();
+		this.configurationService.onDidChangeConfiguration(e => {
+			if (e.affectsConfiguration(offlineModeSetting)) {
+				this.updateEnabled();
+			}
+		});
+	}
+
+	private updateEnabled() {
+		this.enabled = this.configurationService.getValue(offlineModeSetting) !== true;
+	}
+
+	run(): TPromise<any> {
+		if (this.storageService.getBoolean(this.disclaimerStorageKey, StorageScope.GLOBAL, false) === false) {
+			this.notificationService.prompt(Severity.Info, localize('offlineModeDisclaimer', "VS Code cannot stop extensions from making network requests in offline mode. If extensions make such requests, please log an issue against them."), [
+				{
+					label: localize('DontShowAgain', "Don't Show Again"),
+					run: () => {
+						this.storageService.store(this.disclaimerStorageKey, true);
+					}
+				}
+			]);
+		}
+		return this.configurationService.updateValue(offlineModeSetting, true);
+	}
+}
+
+export class DisableOfflineMode extends Action {
+	static readonly ID = 'workbench.action.disableOfflineMode';
+	static LABEL = localize('disableOfflineMode', 'Disable Offline Mode');
+
+	constructor(
+		id: string = DisableOfflineMode.ID,
+		label: string = DisableOfflineMode.LABEL,
+		@IConfigurationService private configurationService: IConfigurationService
+	) {
+		super(id, label);
+		this.updateEnabled();
+		this.configurationService.onDidChangeConfiguration(e => {
+			if (e.affectsConfiguration(offlineModeSetting)) {
+				this.updateEnabled();
+			}
+		});
+	}
+
+	private updateEnabled() {
+		this.enabled = this.configurationService.getValue(offlineModeSetting) === true;
+	}
+
+	run(): TPromise<any> {
+		return this.configurationService.updateValue(offlineModeSetting, false);
+	}
+}
+
+export class NotifyUnsupportedFeatureInOfflineMode extends Action {
+	static readonly ID = 'workbench.action.notifyUnsupportedFeatureInOfflineMode';
+
+	constructor(
+		id: string = NotifyUnsupportedFeatureInOfflineMode.ID,
+		label: string = '',
+		@IConfigurationService private configurationService: IConfigurationService,
+		@INotificationService private notificationService: INotificationService
+	) {
+		super(id, label);
+	}
+
+	run(): TPromise<any> {
+		this.notificationService.prompt(Severity.Info, unSupportedInOfflineModeMsg, [
+			{
+				label: DisableOfflineMode.LABEL,
+				run: () => {
+					return this.configurationService.updateValue(offlineModeSetting, false);
+				}
+			}
+		]);
+		return TPromise.as(null);
+	}
+}
+
+MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
+	group: '5_offline',
+	command: {
+		id: EnableOfflineMode.ID,
+		title: localize({ key: 'miEnableOfflineMode', comment: ['&& denotes a mnemonic'] }, "Enable &&Offline Mode")
+	},
+	order: 1,
+	when: ContextKeyExpr.not('config.' + offlineModeSetting)
+});
+
+MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
+	group: '5_offline',
+	command: {
+		id: DisableOfflineMode.ID,
+		title: localize({ key: 'miDisableOfflineMode', comment: ['&& denotes a mnemonic'] }, "Disable &&Offline Mode")
+	},
+	order: 1,
+	when: ContextKeyExpr.has('config.' + offlineModeSetting)
+});
+
+CommandsRegistry.registerCommand(EnableOfflineMode.ID, serviceAccesor => {
+	serviceAccesor.get(IInstantiationService).createInstance(EnableOfflineMode, EnableOfflineMode.ID, EnableOfflineMode.LABEL).run();
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+	command: {
+		id: EnableOfflineMode.ID,
+		title: 'Preferences: Enable Offline Mode'
+	},
+	when: ContextKeyExpr.not('config.' + offlineModeSetting)
+});
+
+CommandsRegistry.registerCommand(DisableOfflineMode.ID, serviceAccesor => {
+	serviceAccesor.get(IInstantiationService).createInstance(DisableOfflineMode, DisableOfflineMode.ID, DisableOfflineMode.LABEL).run();
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+	command: {
+		id: DisableOfflineMode.ID,
+		title: 'Preferences: Disable Offline Mode'
+	},
+	when: ContextKeyExpr.has('config.' + offlineModeSetting)
+});
+
+CommandsRegistry.registerCommand(NotifyUnsupportedFeatureInOfflineMode.ID, serviceAccesor => {
+	serviceAccesor.get(IInstantiationService).createInstance(NotifyUnsupportedFeatureInOfflineMode, NotifyUnsupportedFeatureInOfflineMode.ID, '').run();
+});

src/vs/platform/request/node/request.ts

@@ -25,6 +25,9 @@ export interface IHTTPConfiguration {
 		proxyStrictSSL?: boolean;
 		proxyAuthorization?: string;
 	};
+	workbench?: {
+		enableOfflineMode?: boolean;
+	};
 }
 
 Registry.as<IConfigurationRegistry>(Extensions.Configuration)

src/vs/platform/request/node/requestService.ts

@@ -24,6 +24,7 @@ export class RequestService implements IRequestService {
 	private proxyUrl: string;
 	private strictSSL: boolean;
 	private authorization: string;
+	private isOfflineMode: boolean;
 	private disposables: IDisposable[] = [];
 
 	constructor(
@@ -38,9 +39,14 @@ export class RequestService implements IRequestService {
 		this.proxyUrl = config.http && config.http.proxy;
 		this.strictSSL = config.http && config.http.proxyStrictSSL;
 		this.authorization = config.http && config.http.proxyAuthorization;
+		this.isOfflineMode = config.workbench && config.workbench.enableOfflineMode === true;
 	}
 
 	request(options: IRequestOptions, requestFn: IRequestFunction = request): TPromise<IRequestContext> {
+		if (this.isOfflineMode) {
+			return TPromise.as({ res: { headers: {}, }, stream: null });
+		}
+
 		this.logService.trace('RequestService#request', options.url);
 
 		const { proxyUrl, strictSSL } = this;

src/vs/platform/telemetry/common/telemetryService.ts

@@ -68,6 +68,10 @@ export class TelemetryService implements ITelemetryService {
 	}
 
 	private _updateUserOptIn(): void {
+		if (this._configurationService.getValue('workbench.enableOfflineMode') === true) {
+			this._userOptIn = false;
+			return;
+		}
 		const config = this._configurationService.getValue<any>(TELEMETRY_SECTION_ID);
 		this._userOptIn = config ? config.enableTelemetry : this._userOptIn;
 	}

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

@@ -15,6 +15,7 @@ import { IUpdateService, State, StateType, AvailableForDownload, UpdateType } fr
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IRequestService } from 'vs/platform/request/node/request';
+import { offlineModeSetting } from 'vs/platform/actions/common/offlineMode';
 
 export function createUpdateURL(platform: string, quality: string): string {
 	return `${product.updateUrl}/api/update/${platform}/${quality}/${product.commit}`;
@@ -49,7 +50,7 @@ export abstract class AbstractUpdateService implements IUpdateService {
 		@IRequestService protected requestService: IRequestService,
 		@ILogService protected logService: ILogService,
 	) {
-		if (this.environmentService.disableUpdates) {
+		if (this.environmentService.disableUpdates || this.configurationService.getValue(offlineModeSetting) === true) {
 			this.logService.info('update#ctor - updates are disabled');
 			return;
 		}
@@ -60,7 +61,6 @@ export abstract class AbstractUpdateService implements IUpdateService {
 		}
 
 		const quality = this.getProductQuality();
-
 		if (!quality) {
 			this.logService.info('update#ctor - updates are disabled');
 			return;

src/vs/workbench/electron-browser/main.contribution.ts

@@ -489,6 +489,12 @@ configurationRegistry.registerConfiguration({
 			'description': nls.localize('settingsTocVisible', "Controls whether the settings editor Table of Contents is visible."),
 			'default': true,
 			'scope': ConfigurationScope.WINDOW
+		},
+		'workbench.enableOfflineMode': {
+			'type': 'boolean',
+			'description': nls.localize('settingsOfflineMode', "Enables offline mode where no requests are made over the network by VS Code."),
+			'default': false,
+			'scope': ConfigurationScope.WINDOW
 		}
 	}
 });

src/vs/workbench/parts/extensions/electron-browser/extensionTipsService.ts

@@ -43,6 +43,7 @@ import { assign } from 'vs/base/common/objects';
 import URI from 'vs/base/common/uri';
 import { areSameExtensions, getGalleryExtensionIdFromLocal } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IExperimentService, ExperimentActionType, ExperimentState } from 'vs/workbench/parts/experiments/node/experimentService';
+import { offlineModeSetting } from 'vs/platform/actions/common/offlineMode';
 
 const milliSecondsInADay = 1000 * 60 * 60 * 24;
 const choiceNever = localize('neverShowAgain', "Don't Show Again");
@@ -162,7 +163,8 @@ export class ExtensionTipsService extends Disposable implements IExtensionTipsSe
 
 	private fetchProactiveRecommendations(calledDuringStartup?: boolean): TPromise<void> {
 		let fetchPromise = TPromise.as(null);
-		if (!this.proactiveRecommendationsFetched) {
+		if (!this.proactiveRecommendationsFetched
+			&& this.configurationService.getValue(offlineModeSetting) !== true) {
 			this.proactiveRecommendationsFetched = true;
 
 			// Executable based recommendations carry out a lot of file stats, so run them after 10 secs
@@ -499,7 +501,7 @@ export class ExtensionTipsService extends Disposable implements IExtensionTipsSe
 		let hasSuggestion = false;
 
 		const uri = model.uri;
-		if (!uri || !this.fileService.canHandleResource(uri)) {
+		if (!uri || !this.fileService.canHandleResource(uri) || this.configurationService.getValue(offlineModeSetting) === true) {
 			return;
 		}
 
@@ -717,7 +719,8 @@ export class ExtensionTipsService extends Disposable implements IExtensionTipsSe
 		if (filteredRecs.length === 0
 			|| config.ignoreRecommendations
 			|| config.showRecommendationsOnlyOnDemand
-			|| this.storageService.getBoolean(storageKey, StorageScope.WORKSPACE, false)) {
+			|| this.storageService.getBoolean(storageKey, StorageScope.WORKSPACE, false)
+			|| this.configurationService.getValue(offlineModeSetting) === true) {
 			return;
 		}