Preserve files on exit (aka hot exit)

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

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as fs from 'original-fs';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+
+export const IBackupService = createDecorator<IBackupService>('backupService');
+
+export interface IBackupService {
+	getBackupWorkspaces(): string[];
+	clearBackupWorkspaces(): void;
+	pushBackupWorkspaces(workspaces: string[]): void;
+	getBackupFiles(workspace: string): string[];
+}
+
+interface IBackupFormat {
+	folderWorkspaces?: {
+		[workspacePath: string]: string[]
+	};
+}
+
+export class BackupService implements IBackupService {
+
+	private fileContent: IBackupFormat;
+
+	constructor(
+		@IEnvironmentService private environmentService: IEnvironmentService
+	) {
+	}
+
+	public getBackupWorkspaces(): string[] {
+		if (!this.fileContent) {
+			this.load();
+		}
+		return Object.keys(this.fileContent.folderWorkspaces || Object.create(null));
+	}
+
+	public clearBackupWorkspaces(): void {
+		this.fileContent = {
+			folderWorkspaces: Object.create(null)
+		};
+		this.save();
+	}
+
+	public pushBackupWorkspaces(workspaces: string[]): void {
+		this.load();
+		workspaces.forEach(workspace => {
+			if (!this.fileContent.folderWorkspaces[workspace]) {
+				this.fileContent.folderWorkspaces[workspace] = [];
+			}
+		});
+		this.save();
+	}
+
+	public getBackupFiles(workspace: string): string[] {
+		this.load();
+		return this.fileContent.folderWorkspaces[workspace];
+	}
+
+	private load(): void {
+		try {
+			this.fileContent = JSON.parse(fs.readFileSync(this.environmentService.backupWorkspacesPath).toString()); // invalid JSON or permission issue can happen here
+		} catch (error) {
+			this.fileContent = Object.create(null);
+		}
+		if (Array.isArray(this.fileContent) || typeof this.fileContent !== 'object') {
+			this.fileContent = Object.create(null);
+		}
+		if (!this.fileContent.folderWorkspaces) {
+			this.fileContent.folderWorkspaces = Object.create(null);
+		}
+	}
+
+	private save(): void {
+		try {
+			fs.writeFileSync(this.environmentService.backupWorkspacesPath, JSON.stringify(this.fileContent));
+		} catch (error) {
+		}
+	}
+}

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

@@ -32,6 +32,7 @@ import { ServiceCollection } from 'vs/platform/instantiation/common/serviceColle
 import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 import { ILogService, MainLogService } from 'vs/code/electron-main/log';
 import { IStorageService, StorageService } from 'vs/code/electron-main/storage';
+import { IBackupService, BackupService } from 'vs/code/electron-main/backup';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { EnvironmentService } from 'vs/platform/environment/node/environmentService';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
@@ -255,11 +256,11 @@ function main(accessor: ServicesAccessor, mainIpcServer: Server, userEnv: platfo
 
 	// Open our first window
 	if (environmentService.args['new-window'] && environmentService.args._.length === 0) {
-		windowsService.open({ cli: environmentService.args, forceNewWindow: true, forceEmpty: true }); // new window if "-n" was used without paths
+		windowsService.open({ cli: environmentService.args, forceNewWindow: true, forceEmpty: true, restoreBackups: true }); // new window if "-n" was used without paths
 	} else if (global.macOpenFiles && global.macOpenFiles.length && (!environmentService.args._ || !environmentService.args._.length)) {
-		windowsService.open({ cli: environmentService.args, pathsToOpen: global.macOpenFiles }); // mac: open-file event received on startup
+		windowsService.open({ cli: environmentService.args, pathsToOpen: global.macOpenFiles, restoreBackups: true }); // mac: open-file event received on startup
 	} else {
-		windowsService.open({ cli: environmentService.args, forceNewWindow: environmentService.args['new-window'], diffMode: environmentService.args.diff }); // default: read paths from cli
+		windowsService.open({ cli: environmentService.args, forceNewWindow: environmentService.args['new-window'], diffMode: environmentService.args.diff, restoreBackups: true }); // default: read paths from cli
 	}
 }
 
@@ -474,6 +475,7 @@ function start(): void {
 	services.set(IConfigurationService, new SyncDescriptor(ConfigurationService));
 	services.set(IRequestService, new SyncDescriptor(RequestService));
 	services.set(IUpdateService, new SyncDescriptor(UpdateManager));
+	services.set(IBackupService, new SyncDescriptor(BackupService));
 	services.set(IURLService, new SyncDescriptor(URLService, args['open-url']));
 
 	const instantiationService = new InstantiationService(services);

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

@@ -14,6 +14,7 @@ import * as types from 'vs/base/common/types';
 import * as arrays from 'vs/base/common/arrays';
 import { assign, mixin } from 'vs/base/common/objects';
 import { EventEmitter } from 'events';
+import { IBackupService } from 'vs/code/electron-main/backup';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { IStorageService } from 'vs/code/electron-main/storage';
 import { IPath, VSCodeWindow, ReadyState, IWindowConfiguration, IWindowState as ISingleWindowState, defaultWindowState, IWindowSettings } from 'vs/code/electron-main/window';
@@ -49,6 +50,7 @@ export interface IOpenConfiguration {
 	forceEmpty?: boolean;
 	windowToUse?: VSCodeWindow;
 	diffMode?: boolean;
+	restoreBackups?: boolean;
 }
 
 interface IWindowState {
@@ -166,7 +168,8 @@ export class WindowsManager implements IWindowsService {
 		@IEnvironmentService private environmentService: IEnvironmentService,
 		@ILifecycleService private lifecycleService: ILifecycleService,
 		@IUpdateService private updateService: IUpdateService,
-		@IConfigurationService private configurationService: IConfigurationService
+		@IConfigurationService private configurationService: IConfigurationService,
+		@IBackupService private backupService: IBackupService
 	) { }
 
 	onOpen(clb: (path: IPath) => void): () => void {
@@ -602,6 +605,18 @@ export class WindowsManager implements IWindowsService {
 			iPathsToOpen = this.cliToPaths(openConfig.cli, ignoreFileNotFound);
 		}
 
+		// Add any existing backup workspaces
+		if (openConfig.restoreBackups) {
+			// TODO: Ensure the workspaces being added actually have backups
+			this.backupService.getBackupWorkspaces().forEach(ws => {
+				iPathsToOpen.push(this.toIPath(ws));
+			});
+			// Get rid of duplicates
+			iPathsToOpen = arrays.distinct(iPathsToOpen, path => {
+				return path.workspacePath;
+			});
+		}
+
 		let filesToOpen: IPath[] = [];
 		let filesToDiff: IPath[] = [];
 		let foldersToOpen = iPathsToOpen.filter(iPath => iPath.workspacePath && !iPath.filePath);
@@ -730,6 +745,12 @@ export class WindowsManager implements IWindowsService {
 		// Emit events
 		iPathsToOpen.forEach(iPath => this.eventEmitter.emit(EventTypes.OPEN, iPath));
 
+		// Add to backups
+		console.log('iPathsToOpen', iPathsToOpen);
+		this.backupService.pushBackupWorkspaces(iPathsToOpen.map((path) => {
+			return path.workspacePath;
+		}));
+
 		return arrays.distinct(usedWindows);
 	}
 

src/vs/platform/backup/common/backup.ts

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import Uri from 'vs/base/common/uri';
+
+export const IBackupService = createDecorator<IBackupService>('backupService');
+
+export interface IBackupService {
+	_serviceBrand: any;
+
+	getBackupWorkspaces(): string[];
+	clearBackupWorkspaces(): void;
+	removeWorkspace(workspace: string): void;
+
+	registerBackupFile(resource: Uri): void;
+	deregisterBackupFile(resource: Uri): void;
+	getBackupFiles(workspace: string): string[];
+	getBackupUntitledFiles(workspace: string): string[];
+	getBackupResource(resource: Uri): Uri;
+}

src/vs/platform/environment/common/environment.ts

@@ -23,6 +23,9 @@ export interface IEnvironmentService {
 	appSettingsPath: string;
 	appKeybindingsPath: string;
 
+	backupHome: string;
+	backupWorkspacesPath: string;
+
 	disableExtensions: boolean;
 	extensionsPath: string;
 	extensionDevelopmentPath: string;

src/vs/platform/environment/node/environmentService.ts

@@ -76,6 +76,12 @@ export class EnvironmentService implements IEnvironmentService {
 	@memoize
 	get appKeybindingsPath(): string { return path.join(this.appSettingsHome, 'keybindings.json'); }
 
+	@memoize
+	get backupHome(): string { return path.join(this.userDataPath, 'Backups'); }
+
+	@memoize
+	get backupWorkspacesPath(): string { return path.join(this.backupHome, 'workspaces.json'); }
+
 	@memoize
 	get extensionsPath(): string { return path.normalize(this._args.extensionHomePath || path.join(this.userHome, 'extensions')); }
 

src/vs/platform/files/common/files.ts

@@ -104,6 +104,27 @@ export interface IFileService {
 	 */
 	del(resource: URI, useTrash?: boolean): TPromise<void>;
 
+	/**
+	 * Backs up the provided file to a temporary directory to be used by the hot
+	 * exit feature and crash recovery.
+	 */
+	backupFile(resource: URI, content: string): TPromise<IFileStat>;
+
+	/**
+	 * Discard the backup for the resource specified.
+	 */
+	discardBackup(resource: URI): TPromise<void>;
+
+	/**
+	 * Discards all backups associated with this session.
+	 */
+	discardBackups(): TPromise<void>;
+
+	/**
+	 * Whether hot exit is enabled.
+	 */
+	isHotExitEnabled(): boolean;
+
 	/**
 	 * Imports the file to the parent identified by the resource.
 	 */
@@ -475,6 +496,7 @@ export interface IFilesConfiguration {
 		autoSave: string;
 		autoSaveDelay: number;
 		eol: string;
+		hotExit: boolean;
 	};
 }
 

src/vs/test/utils/servicesTestUtils.ts

@@ -17,6 +17,7 @@ import { Storage, InMemoryLocalStorage } from 'vs/workbench/node/storage';
 import { IEditorGroup, ConfirmResult } from 'vs/workbench/common/editor';
 import Event, { Emitter } from 'vs/base/common/event';
 import Severity from 'vs/base/common/severity';
+import {IBackupService} from 'vs/platform/backup/common/backup';
 import { IConfigurationService, getConfigurationValue, IConfigurationValue } from 'vs/platform/configuration/common/configuration';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { IQuickOpenService } from 'vs/workbench/services/quickopen/common/quickOpenService';
@@ -110,9 +111,10 @@ export class TestTextFileService extends TextFileService {
 		@IEditorGroupService editorGroupService: IEditorGroupService,
 		@IFileService fileService: IFileService,
 		@IUntitledEditorService untitledEditorService: IUntitledEditorService,
-		@IInstantiationService instantiationService: IInstantiationService
+		@IInstantiationService instantiationService: IInstantiationService,
+		@IBackupService backupService: IBackupService
 	) {
-		super(lifecycleService, contextService, configurationService, telemetryService, editorGroupService, editorService, fileService, untitledEditorService, instantiationService);
+		super(lifecycleService, contextService, configurationService, telemetryService, editorGroupService, editorService, fileService, untitledEditorService, instantiationService, backupService);
 	}
 
 	public setPromptPath(path: string): void {
@@ -572,6 +574,18 @@ export const TestFileService = {
 				name: paths.basename(res.fsPath)
 			};
 		});
+	},
+
+	discardBackup: function (resource: URI) {
+		return TPromise.as(void 0);
+	},
+
+	discardBackups: function () {
+		return TPromise.as(void 0);
+	},
+
+	isHotExitEnabled: function () {
+		return false;
 	}
 };