feat: out of sync handling for dev mode

Author: jakobrosenberg

src/Device.js

@@ -91,6 +91,8 @@ class Device {
       ),
       wasConnected: createStateObject(pymakr.context.workspaceState, `pymakr.devices.${this.id}.wasConnected`, true),
       pymakrConf: createStateObject(pymakr.context.globalState, `pymakr.devices.${this.id}.pymakrConf`, pymakrConfType),
+      /** Last time this project was updated by dev upload. If value doesn't match project, device is considered stale */
+      devUploadedAt: createStateObject(pymakr.context.globalState, `project.${this.id}.devUploadedAt`),
       /** @type {import("./utils/storageObj").GetterSetter<import("micropython-ctl-cont").BoardInfo>} */
       info: createStateObject(pymakr.context.globalState, `pymakr.devices.${this.id}.info`),
     };

src/Project.js

@@ -1,6 +1,5 @@
 const { readFileSync } = require("fs");
 const { dirname, basename } = require("path");
-const vscode = require("vscode");
 const { createStateObject } = require("./utils/storageObj");
 const { Watcher } = require("./Watcher/Watcher");
 
@@ -16,9 +15,19 @@ class Project {
     this.folder = dirname(configFile.fsPath);
     this.watcher = new Watcher(this);
 
-    this.deviceIds = createStateObject(pymakr.context.globalState, `project.${this.folder}`, []);
-    this.name = this.config.name || basename(this.folder);
+    this.deviceIds = createStateObject(pymakr.context.globalState, `project.${this.folder}.deviceIds`, []);
+    this.updatedAt = createStateObject(pymakr.context.globalState, `project.${this.folder}.updatedAt`);
+
     this.log = pymakr.log.createChild("project: " + this.name);
+    this.refresh();
+  }
+
+  refresh() {
+    this.name = this.config.name || basename(this.folder);
+  }
+
+  destroy() {
+    this.watcher.destroy();
   }
 
   get config() {

src/Watcher/DeviceManager.js

@@ -24,13 +24,31 @@ class DeviceManager {
     this.isRunning = false;
   }
 
+  get outOfSync() {
+    return this.device.state.devUploadedAt.get() !== this.watcher.project.updatedAt.get();
+  }
+
+  get shouldUploadOnDev() {
+    const uploadWhen = this.watcher.project.config.dev?.uploadOnDevStart || "outOfSync";
+    return uploadWhen === "always" || (uploadWhen === "outOfSync" && this.outOfSync);
+  }
+
+  async uploadProjectIfNeeded() {
+    if (!this.device.adapter.__proxyMeta.target.isConnected()) return;
+
+    const answer = await this.device.pymakr.notifier.notifications.deviceIsOutOfSync(this);
+
+    if (this.shouldUploadOnDev || answer === "upload")
+      await this.device.pymakr.commands.uploadProject({ device: this.device, project: this.watcher.project });
+  }
+
   /**
    * Send a change/create/delete file instruction to the device
    * @param {FileInstruction} fileInstruction
    */
   push(fileInstruction) {
     this.fileInstructions.push(fileInstruction);
-    this.handleNewInstructions();
+    return this.handleNewInstructions();
   }
 
   async handleNewInstructions() {
@@ -44,7 +62,7 @@ class DeviceManager {
     this.log.debug("device/script restart completed");
 
     // If new instructions were added while we restarted the device/script, let's rerun.
-    if (this.fileInstructions.length) this.handleNewInstructions();
+    if (this.fileInstructions.length) await this.handleNewInstructions();
   }
 
   /**

src/Watcher/Watcher.js

@@ -13,6 +13,7 @@ class Watcher {
     /** @type {vscode.Disposable[]} */
     this.disposables = [];
     this.active = false;
+    this.registerFileWatchers();
   }
 
   /**
@@ -22,24 +23,16 @@ class Watcher {
     if (!this.deviceManagers.map((dm) => dm.device).includes(device))
       this.deviceManagers.push(new DeviceManager(this, device));
 
-    if (this.deviceManagers.length) this.start();
+    if (this.deviceManagers.length) this.active = true;
+    this.deviceManagers.find((dm) => dm.device === device)?.uploadProjectIfNeeded();
   }
 
   removeDevice(device) {
     this.deviceManagers = [...this.deviceManagers.filter((dm) => dm.device !== device)];
-    if (!this.deviceManagers.length) this.stop();
+    if (!this.deviceManagers.length) this.active = false;
   }
 
-  /**
-   * called whenever addDevice is called
-   */
-  start() {
-    if (this.active) return;
-    this.active = true;
-    this.onStart();
-  }
-
-  onStart() {
+  registerFileWatchers() {
     // this.deviceManagers = this.devices.map((device) => new DeviceManager(this, device));
     this.watcher = vscode.workspace.createFileSystemWatcher(this.project.folder + "/**");
     this.disposables = [
@@ -50,20 +43,25 @@ class Watcher {
     ];
   }
 
-  stop() {
+  destroy() {
     this.disposables.forEach((d) => d.dispose());
-    this.active = false;
   }
 
   /**
    * @param {'create'|'change'|'delete'} action
    * @returns {(file: vscode.Uri)=>void}
    */
   handleFileChange(action) {
-    return async (file) => {
-      this.deviceManagers
-        .filter((dm) => dm.device.adapter.__proxyMeta.target.isConnected())
-        .forEach((manager) => manager.push({ file: file.fsPath, action }));
+    return (file) => {
+      const timestamp = new Date();
+      this.project.updatedAt.set(timestamp);
+      if (this.active)
+        this.deviceManagers
+          .filter((dm) => dm.device.adapter.__proxyMeta.target.isConnected())
+          .forEach(async (manager) => {
+            await manager.push({ file: file.fsPath, action });
+            manager.device.state.devUploadedAt.set(timestamp);
+          });
     };
   }
 }

src/commands/index.js

@@ -544,17 +544,28 @@ class Commands {
      * @param {{ device: Device, project: Project }} treeItem
      */
     uploadProject: async ({ device, project }) => {
-      if (project.watcher.active) {
-        const deviceManager = project.watcher.deviceManagers.find((d) => d.device === device);
-        deviceManager.push({ action: "create", file: project.folder });
-        this.pymakr.notifier.notifications.uploadInDevMode();
-      } else {
+      if (project.watcher.active) return this.commands.uploadProjectDev({ device, project });
+      else {
+        this.log.debug("uploadProject", device, project);
         await device.adapter.remove(device.config.rootPath, true);
         this.commands.upload({ fsPath: project.folder }, device, "/");
         this.pymakr.notifier.notifications.uploadProject();
       }
     },
 
+    /**
+     * Uploads parent project to the device. Can only be accessed from devices in the projects view.
+     * @param {{ device: Device, project: Project }} treeItem
+     */
+    uploadProjectDev: async ({ device, project }) => {
+      this.log.debug("uploadDevProject", device, project);
+      const deviceManager = project.watcher.deviceManagers.find((d) => d.device === device);
+      this.pymakr.notifier.notifications.uploadInDevMode();
+      const timestamp = project.updatedAt.get();
+      await deviceManager.push({ action: "create", file: project.folder });
+      deviceManager.device.state.devUploadedAt.set(timestamp);
+    },
+
     /**
      * Prompts for a device and destination for uploading a file or folder
      * @param {vscode.Uri} uri

src/stores/projects.js

@@ -3,12 +3,35 @@ const { Project } = require("../Project");
 const { writable } = require("../utils/store");
 
 /**
- * @param {PyMakr} pymakr
+ * @param {import('../PyMakr').PyMakr} pymakr
+ * @returns {(configFile: import('vscode').Uri)=>Project}
  */
-const getProjects = async (pymakr) => {
-  const configFiles = await workspace.findFiles("**/pymakr.conf");
-  return configFiles.map((configFile) => new Project(configFile, pymakr));
-};
+const convertToProject = (pymakr) => (configFile) => new Project(configFile, pymakr);
+
+/** @param {Project[]} projects */
+const isNotIn = (projects) => (configFile) => !projects.find((p) => p.configFile.path === configFile.path);
+
+/**
+ * @param {Project} p1
+ * @param {Project} p2
+ */
+const byName = (p1, p2) => (p1.name < p2.name ? 1 : p1.name > p2.name ? -1 : 0);
+
+/**
+ * @param {import('vscode').Uri[]} configFiles
+ * @returns {(project:Project) => Boolean}
+ */
+const hasConfigFile = (configFiles) => (project) => configFiles.map((cf) => cf.path).includes(project.configFile.path);
+
+/**
+ * @param {import('vscode').Uri[]} configFiles
+ * @returns {(project:Project) => Boolean}
+ */
+const hasNoConfigFile = (configFiles) => (project) =>
+  !configFiles.map((cfg) => cfg.path).includes(project.configFile.path);
+
+/** @param {Project} project */
+const destroy = (project) => project.destroy();
 
 /**
  * @param {PyMakr} pymakr
@@ -19,7 +42,15 @@ const createProjectsStore = (pymakr) => {
   /** Rescan for projects in workspace. */
   const refresh = async () => {
     pymakr.log.debug("Refreshing projects store...");
-    store.set(await getProjects(pymakr));
+    const configFiles = await workspace.findFiles("**/pymakr.conf");
+    store.get().filter(hasNoConfigFile(configFiles)).forEach(destroy);
+    store.update((oldProjects) =>
+      [
+        ...oldProjects.filter(hasConfigFile(configFiles)),
+        ...configFiles.filter(isNotIn(oldProjects)).map(convertToProject(pymakr)),
+      ].sort(byName)
+    );
+    store.get().forEach((p) => p.refresh());
     pymakr.log.debug("Refreshing projects store. Complete!");
   };
 

src/utils/Notifier.js

@@ -200,6 +200,36 @@ class Notifier {
           "": [null, this.DONT_SHOW_AGAIN],
         }
       ),
+
+    /**
+     *
+     * @param {import('../Watcher/DeviceManager').DeviceManager} deviceManager
+     * @returns
+     */
+    deviceIsOutOfSync: (deviceManager) => {
+      if (deviceManager.outOfSync && deviceManager.shouldUploadOnDev)
+        this.createNotification(
+          "info",
+          `[DEV] Uploaded project to "${deviceManager.device.name}", since device appeared to be out of sync.`,
+          { "": [null, this.DONT_SHOW_AGAIN] }
+        );
+      else if (deviceManager.shouldUploadOnDev)
+        this.createNotification(
+          "info",
+          `[DEV] Uploaded project to "${deviceManager.device.name}" since "uploadOnDevStart" is set to "always".`,
+          { "": [null, this.DONT_SHOW_AGAIN] }
+        );
+      else if (deviceManager.outOfSync)
+        return this.createNotification(
+          "warning",
+          "[DEV] Device is out of sync. Consider changing 'dev.uploadOnDevStart' in 'pymakr.conf'.",
+          { "": [null, this.DONT_SHOW_AGAIN], upload: `Upload project to ${deviceManager.device.name}` }
+        );
+      else
+        this.createNotification("info", `[DEV] Device "${deviceManager.device.name}" is up to date.`, {
+          "": [null, this.DONT_SHOW_AGAIN],
+        });
+    },
   };
 }