querysub 0.293.0 → 0.295.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.293.0",
+  "version": "0.295.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/4-deploy/edgeClientWatcher.tsx

@@ -66,7 +66,8 @@ function onLiveHashChange(liveHash: string, refreshThresholdTime: number) {
     if (liveHash === curHash) return;
     let prevHash = curHash;
     // Don't notify the user right away. Hopefully they refresh naturally, and we never have to notify them at all!
-    let notifyIntervals = [0.4, 0.75, 1];
+    // Also, refresh BEFORE the server dies, not exactly when it is about to die
+    let notifyIntervals = [0.4, 0.75, 0.95];
     console.log(blue(`Client liveHash changed ${liveHash}, prev hash: ${prevHash}`));
     // If we are replacing an already existing notification, don't show immediately
     let skipFirst = false;

package/src/deployManager/components/MachineDetailPage.tsx

@@ -26,6 +26,7 @@ export class MachineDetailPage extends qreact.Component {
         let relevantServiceConfigs = new Map<string, ServiceConfig>();
         for (let serviceId of serviceList) {
             let serviceConfig = controller.getServiceConfig(serviceId);
+            if (!serviceConfig?.parameters.deploy) continue;
             if (serviceConfig && serviceConfig.machineIds.includes(selectedMachineId)) {
                 relevantServiceConfigs.set(serviceId, serviceConfig);
             }

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -359,9 +359,9 @@ type ServiceConfig = ${serviceConfigType}
                                 </div>
                                 {serviceInfo && (
                                     <>
-                                        <div title={formatVeryNiceDateTime(serviceInfo.lastLaunchedTime)}>
+                                        {!!serviceInfo.lastLaunchedTime && <div title={formatVeryNiceDateTime(serviceInfo.lastLaunchedTime)}>
                                             Uptime: {formatTime(now - serviceInfo.lastLaunchedTime)}
-                                        </div>
+                                        </div>}
                                         <div>
                                             Launches: {serviceInfo.totalTimesLaunched}
                                         </div>

package/src/deployManager/machineApplyMainCode.ts

@@ -349,6 +349,7 @@ const runScreenCommand = measureWrap(async function runScreenCommand(config: {
                 // REMOVE the nodeId file, so we the node isn't terminated!
                 await fs.promises.unlink(nodeIdPath);
                 try {
+                    console.log(green(`Triggering rolling update notification to ${nodeId} for ${screenName} at ${new Date().toLocaleString()}`));
                     await triggerRollingUpdate({
                         nodeId,
                         time: rollingFinalTime,
@@ -361,7 +362,7 @@ const runScreenCommand = measureWrap(async function runScreenCommand(config: {
             console.log(green(`Renaming screen ${screenName} to ${rollingScreenName} for rolling interval ${config.rollingWindow} at ${new Date().toLocaleString()}`));
             await runPromise(`${prefix}tmux rename-session -t ${screenName} ${rollingScreenName}`);
             rollingScreens.set(rollingScreenName, screenName);
-            rollingKeepScreenAlive.set(rollingScreenName, {
+            rollingKeepScreenAlive.set(screenName, {
                 rollingScreenName,
                 originalScreenName: screenName,
                 pinnedDuration: config.rollingWindow,
@@ -448,7 +449,16 @@ done`);
 const killScreen = measureWrap(async function killScreen(config: {
     screenName: string;
 }) {
+    console.log(red(`Killing screen ${config.screenName}`));
     let prefix = getTmuxPrefix();
+    // Try ctrl+c a few times first
+    for (let i = 0; i < 5; i++) {
+        if (!await isScreenRunningProcess(config.screenName)) {
+            break;
+        }
+        await runPromise(`${prefix}tmux send-keys -t ${config.screenName} 'C-c' Enter`);
+        await delay(5000);
+    }
     await runPromise(`${prefix}tmux kill-session -t ${config.screenName}`);
     await removeOldNodeId(config.screenName);
 });
@@ -478,6 +488,13 @@ let lastLaunchedTimePerService = new Map<string, number>();
 
 async function quickIsOutdated() {
     let machineId = getOwnMachineId();
+    // If any rolling are ready to restart, we are outdated
+    for (let [rollingScreenName, rollingInfo] of rollingKeepScreenAlive) {
+        if (rollingInfo.pinnedTime + rollingInfo.pinnedDuration < Date.now()) {
+            console.log(red(`Rolling screen ${rollingScreenName} is finished, doing a full resync`));
+            return true;
+        }
+    }
     let configs = await serviceConfigs.values();
     let relevantConfigs = configs.filter(config => config.machineIds.includes(machineId)).filter(x => x.parameters.deploy);
     let screens = await getScreenState();
@@ -499,7 +516,6 @@ async function quickIsOutdated() {
             if (!fs.existsSync(parameterPath)) return true;
             let prevParameters = await fs.promises.readFile(parameterPath, "utf8");
             if (prevParameters !== newParametersString) return true;
-
         }
     }
     return false;
@@ -629,7 +645,10 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 rollingKeepScreenAlive.delete(rollingScreenRemainder);
                 rollingInfo = undefined;
             }
-            if (rollingInfo) continue;
+            if (rollingInfo) {
+                console.log(green(`Skipping killing rolling screen ${screenName} because it's still alive at ${new Date().toLocaleString()}. Keeping it alive until ${new Date(rollingInfo.pinnedTime + rollingInfo.pinnedDuration).toLocaleString()}`));
+                continue;
+            }
         }
         await killScreen({
             screenName,

package/src/deployManager/spec.txt

@@ -1,26 +1,8 @@
 Hmm... our cyoa servers are dying very fast... why?
 
-9) Rolling service updates
-    - Add rollingWindow to the definition
-    - Set for public facing services (but not for scripts)
-        - PathValueServer - 10 minutes
-        - FunctionRunner - CANNOT use rolling
-        - HTTP - 4 hours
-        - Boostrapper - NO rolling
-        - gc/join - NO rolling
-    - Show the rolling time in the update buttons (both list and the save button on the details page), so we know it will be a rolling update
-    - Keep the oldest service alive when we update
-        - Tracked per serviceId
-        - Update the rolling time, so if we remove the rolling window we kill the old service immediately
-    - Notify when servers are outdated
-        - After min(5 minute, 10% of rolling window size)
-        - Use the node registration to know the nodeId to talk to, and allow servers to register to get told when they are outdated (and how long before they are shutdown).
-        - In HTTP server, notify users, in the same way we notify for hash updates, that they will need to switch servers
-        - Verify this update works with a relatively low rolling update window, ensuring it force refreshes before the server actually restarts.
-
-10) Verify we can using a rolling update with CYOA, and that it'll notify users, then refresh (eventually)
-    - I guess set the rollingWindow to 10 minutes for testing.
-
+1) Verify clientside notifications work when we rolling update cyoa
+2) Verify edge nodes are removed when we rolling update cyoa
+3) Update cyoa rolling time back to 4 hours
 
 10) Add RAM total, ram % used, cpu count, CPU %, disk size, disk % used to machine info
     - Show this all in the list page, with nice bars?