feat: project backup and restore working

Author: abose

src/extensions/default/NavigationAndHistory/FileRecovery.js

@@ -25,12 +25,22 @@ define(function (require, exports, module) {
     const NativeApp = brackets.getModule("utils/NativeApp"),
         FileSystem = brackets.getModule("filesystem/FileSystem"),
         ProjectManager = brackets.getModule("project/ProjectManager"),
+        MainViewManager = brackets.getModule("view/MainViewManager"),
         FileSystemError = brackets.getModule("filesystem/FileSystemError"),
         FileUtils = brackets.getModule("file/FileUtils"),
-        DocumentManager = brackets.getModule("document/DocumentManager");
+        DocumentManager = brackets.getModule("document/DocumentManager"),
+        NotificationUI = brackets.getModule("widgets/NotificationUI"),
+        Mustache = brackets.getModule("thirdparty/mustache/mustache"),
+        Strings = brackets.getModule("strings"),
+        FileViewController  = brackets.getModule("project/FileViewController"),
+        recoveryTemplate = require("text!html/recovery-template.html"),
+        EventDispatcher = brackets.getModule("utils/EventDispatcher"),
+        EventManager = brackets.getModule("utils/EventManager");
 
-    const BACKUP_INTERVAL_MS = 3000; // todo change to 20 secs
-    // todo large number of tracked files performance issues?
+    EventDispatcher.makeEventDispatcher(exports);
+    EventManager.registerEventHandler("ph-recovery", exports);
+
+    const BACKUP_INTERVAL_MS = 5000;
     const sessionRestoreDir = FileSystem.getDirectoryForPath(
         path.normalize(NativeApp.getApplicationSupportDirectory() + "/sessionRestore"));
 
@@ -131,6 +141,7 @@ define(function (require, exports, module) {
         let restoreFolder = project.restoreRoot;
         await ensureFolderIsClean(restoreFolder);
         let allEntries = await FileSystem.getAllDirectoryContents(restoreFolder);
+        let backupExists = false;
         for(let entry of allEntries){
             if(entry.isDirectory){
                 continue;
@@ -145,9 +156,20 @@ define(function (require, exports, module) {
                 return;
             }
             project.lastBackedUpFileContents[projectFilePath] = text;
-            console.log(text);
+            backupExists = true;
         }
         project.lastBackedupLoadInProgress = false;
+        if(backupExists) {
+            let notificationHTML = Mustache.render(recoveryTemplate, {
+                Strings: Strings,
+                PROJECT_TO_RECOVER: projectRootPath
+            });
+            project.restoreNotification = NotificationUI.createToastFromTemplate( Strings.RECOVER_UNSAVED_FILES_TITLE,
+                notificationHTML, {
+                    dismissOnClick: false,
+                    toastStyle: NotificationUI.NOTIFICATION_STYLES_CSS_CLASS.SUCCESS
+                });
+        }
     }
 
     function projectOpened(_event, projectRoot) {
@@ -156,14 +178,21 @@ define(function (require, exports, module) {
             return;
         }
         if(trackedProjects[projectRoot.fullPath]){
-            trackedProjects[projectRoot.fullPath].projectLoadCount++;
+            if(trackedProjects[projectRoot.fullPath].restoreNotification){
+                trackedProjects[projectRoot.fullPath].restoreNotification.close();
+                trackedProjects[projectRoot.fullPath].restoreNotification = null;
+            }
+            trackedProjects[projectRoot.fullPath].projectLoadCount++;// we use this to prevent race conditions
+            // on frequent project switch before all project backup files are loaded.
             trackedProjects[projectRoot.fullPath].lastBackedUpFileContents = {};
             trackedProjects[projectRoot.fullPath].firstEditHandled = false;
             trackedProjects[projectRoot.fullPath].lastBackedupLoadInProgress = true;
             trackedProjects[projectRoot.fullPath].trackedFileUpdateTimestamps = {};
             trackedProjects[projectRoot.fullPath].trackedFileContents = {};
-            loadLastBackedUpFileContents(projectRoot.fullPath);
-            // todo race condition here frequent switch between projects
+            trackedProjects[projectRoot.fullPath].changeErrorReported = false;
+            loadLastBackedUpFileContents(projectRoot.fullPath).catch(err=>{
+                console.error("[recovery] loadLastBackedUpFileContents failed ", err);
+            });
             return;
         }
         trackedProjects[projectRoot.fullPath] = {
@@ -176,9 +205,13 @@ define(function (require, exports, module) {
             lastBackedupLoadInProgress: true, // while the backup is loading, we need to prevent write over the existing
             // backup with backup info of the current session
             trackedFileUpdateTimestamps: {},
-            trackedFileContents: {}
+            trackedFileContents: {},
+            restoreNotification: null,
+            changeErrorReported: false // we only report change errors once to prevent too many Bugsnag reports
         };
-        loadLastBackedUpFileContents(projectRoot.fullPath);
+        loadLastBackedUpFileContents(projectRoot.fullPath).catch(err=>{
+            console.error("[recovery] loadLastBackedUpFileContents failed ", err);
+        });
     }
 
     async function writeFileIgnoreFailure(filePath, contents) {
@@ -189,7 +222,6 @@ define(function (require, exports, module) {
             await jsPromise(FileUtils.writeText(file, contents, true));
         } catch (e) {
             console.error(e);
-            logger.reportError(e); // todo too many error reports prevent every 20 secs
         }
     }
 
@@ -217,6 +249,12 @@ define(function (require, exports, module) {
     }
 
     let backupInProgress = false;
+
+    /**
+     * This gets executed every 5 seconds and should be as light-weight as possible. If there are no changes to be
+     * backed up, then this function should return as soon as possible without waiting for any async flows.
+     * @return {Promise<void>}
+     */
     async function changeScanner() {
         let currentProjectRoot = ProjectManager.getProjectRoot();
         const project = trackedProjects[currentProjectRoot.fullPath];
@@ -255,21 +293,71 @@ define(function (require, exports, module) {
                 await cleanupUntrackedFiles(docPathsToTrack, currentProjectRoot);
             }
         } catch (e) {
-            console.error(e);
-            logger.reportError(e);
+            console.error("[recovery] changeScanner error", e);
+            if(!project.changeErrorReported){
+                project.changeErrorReported = true;
+                // we only report change errors once to prevent too many Bugsnag reports
+                logger.reportError(e);
+            }
         }
         backupInProgress = false;
     }
 
     function beforeProjectClosed() {
-        changeScanner();
+        let currentProjectRoot = ProjectManager.getProjectRoot();
+        const project = trackedProjects[currentProjectRoot.fullPath];
+        if(project.restoreNotification) {
+            project.restoreNotification.close();
+        }
+        changeScanner().catch(err=>{
+            console.error("[recovery] beforeProjectClosed failed which scanning for changes to backup", err);
+        });
+    }
+
+    async function ensureOpenEditors(pathList) {
+        let allOpenFiles = MainViewManager.getAllOpenFiles();
+        let openFilePaths = {};
+        for(let file of allOpenFiles){
+            openFilePaths[file.fullPath] = true;
+        }
+        for(let path of pathList) {
+            if(!openFilePaths[path]){
+                let file = FileSystem.getFileForPath(path);
+                await jsPromise(FileViewController.openFileAndAddToWorkingSet(file.fullPath));
+            }
+        }
+    }
+
+    async function restoreBtnClicked(_event, projectToRestore) {
+        let currentProjectRoot = ProjectManager.getProjectRoot();
+        const project = trackedProjects[currentProjectRoot.fullPath];
+        if(!project || projectToRestore !== currentProjectRoot.fullPath){
+            console.error(`[recovery] current project ${currentProjectRoot.fullPath} != restore ${projectToRestore}`);
+            return;
+        }
+        let pathsToRestore = Object.keys(project.lastBackedUpFileContents);
+        await ensureOpenEditors(pathsToRestore);
+        for(let filePath of pathsToRestore){
+            if(ProjectManager.isWithinProject(filePath)) {
+                console.log("restoring", filePath);
+                let document = await jsPromise(DocumentManager.getDocumentForPath(filePath));
+                document.setText(project.lastBackedUpFileContents[filePath]);
+            } else {
+                console.error("[recovery] Skipping restore of non project file: ", filePath);
+            }
+        }
+        if(project.restoreNotification){
+            project.restoreNotification.close();
+            project.restoreNotification = null;
+        }
     }
 
     function init() {
-        ProjectManager.on(ProjectManager.EVENT_AFTER_PROJECT_OPEN, projectOpened);
-        ProjectManager.on(ProjectManager.EVENT_PROJECT_BEFORE_CLOSE, beforeProjectClosed);
-        createDir(sessionRestoreDir);
         if(!window.testEnvironment){
+            ProjectManager.on(ProjectManager.EVENT_AFTER_PROJECT_OPEN, projectOpened);
+            ProjectManager.on(ProjectManager.EVENT_PROJECT_BEFORE_CLOSE, beforeProjectClosed);
+            exports.on("restoreProject", restoreBtnClicked);
+            createDir(sessionRestoreDir);
             setInterval(changeScanner, BACKUP_INTERVAL_MS);
         }
     }

src/extensions/default/NavigationAndHistory/html/recovery-template.html

@@ -0,0 +1,12 @@
+<div>
+  <span>{{Strings.RECOVER_UNSAVED_FILES_MESSAGE}}</span>
+  <br />
+  <button
+    style="float: right; margin-right: 6px"
+    class="btn btn-mini remove primary"
+    data-project="{{PROJECT_TO_RECOVER}}"
+    onclick="EventManager.triggerEvent('ph-recovery', 'restoreProject', this.getAttribute('data-project'))"
+  >
+    Restore
+  </button>
+</div>

src/nls/root/strings.js

@@ -795,6 +795,8 @@ define({
     "RECENT_FILES_DLG_HEADER": "Recent Files",
     "RECENT_FILES_DLG_CLEAR_BUTTON_LABEL": "Clear",
     "RECENT_FILES_DLG_CLEAR_BUTTON_TITLE": "Clear files not in Working Set",
+    "RECOVER_UNSAVED_FILES_TITLE": "Recover Unsaved Files?",
+    "RECOVER_UNSAVED_FILES_MESSAGE": "Restore unsaved files from your previous session with this project?",
 
     // Descriptions of core preferences
     "DESCRIPTION_CLOSE_BRACKETS": "true to automatically close braces, brackets and parentheses",

src/utils/EventManager.js

@@ -38,13 +38,13 @@
  * EventManager = brackets.getModule("utils/EventManager");
  * EventDispatcher.makeEventDispatcher(exports);
  *
- * EventManager.registerEventHandler("drawImageHandler", exports);
+ * EventManager.registerEventHandler("drawImage-Handler", exports);
  * ```
  * Once the event handler is registered, we can trigger events on the named handler anywhere in phoenix
  * (inside or outside the extension) by using:
  *
  * ```js
- * EventManager.triggerEvent("drawImageHandler", "someEventName", "param1", "param2", ...);
+ * EventManager.triggerEvent("drawImage-Handler", "someEventName", "param1", "param2", ...);
  * ```
  * @module utils/EventManager
  */
@@ -60,7 +60,10 @@ define(function (require, exports, module) {
      * const EventDispatcher = brackets.getModule("utils/EventDispatcher"),
      * EventDispatcher.makeEventDispatcher(exports);
      *
-     * EventManager.registerEventHandler("closeDialogueHandler", exports);
+     * // Note: for event handler names, please change the <extensionName> to your extension name
+     * // to prevent collisions. EventHandlers starting with `ph-` and `br-` are reserved as system handlers
+     * // and not available for use in extensions.
+     * EventManager.registerEventHandler("<extensionName>-closeDialogueHandler", exports);
      * // Once the event handler is registered, see triggerEvent API on how to raise events
      *
      * @param {string} handlerName a unique name of the handler.