querysub 0.284.0 → 0.286.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.284.0",
+  "version": "0.286.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

@@ -65,7 +65,8 @@ let curHash = "";
 function onLiveHashChange(liveHash: string, refreshThresholdTime: number) {
     if (liveHash === curHash) return;
     let prevHash = curHash;
-    let notifyIntervals = [0, 0.1, 0.5, 1];
+    // 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];
     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/ServicesListPage.tsx

@@ -45,7 +45,8 @@ export class ServicesListPage extends qreact.Component {
                                     repoUrl: gitInfo.repoUrl,
                                     gitRef: gitInfo.latestRef,
                                     command: "ping 1.1.1.1",
-                                    deploy: false
+                                    deploy: false,
+                                    rollingWindow: 0,
                                 },
                                 info: {
                                     title: `New Service created at ${formatNiceDateTime(Date.now())}`,
@@ -107,8 +108,9 @@ export class ServicesListPage extends qreact.Component {
                                         Deploy: {config.parameters.deploy ? "enabled" : "disabled"}
                                     </div>
                                 </div>
-                                <div>
-                                    Updated {formatDateJSX(config.info.lastUpdatedTime)}
+                                <div className={css.vbox(4)}>
+                                    <div>Updated {formatDateJSX(config.info.lastUpdatedTime)} AGO</div>
+                                    {config.parameters.rollingWindow && <div>Rolling window: {formatTime(config.parameters.rollingWindow)}</div>}
                                 </div>
                             </div>
                         </Anchor>

package/src/deployManager/machineApplyMainCode.ts

@@ -21,7 +21,7 @@ import { lazy } from "socket-function/src/caching";
 import { getGitRefLive, getGitURLLive, setGitRef } from "../4-deploy/git";
 import { blue, green, magenta, red } from "socket-function/src/formatting/logColors";
 import { shutdown } from "../diagnostics/periodic";
-import { onServiceConfigChange } from "./machineController";
+import { onServiceConfigChange, triggerRollingUpdate } from "./machineController";
 import { PromiseObj } from "../promise";
 import path from "path";
 
@@ -314,13 +314,56 @@ async function removeOldNodeId(screenName: string) {
         await forceRemoveNode(nodeId);
     }
 }
+
+
+// originalName => info
+let rollingKeepScreenAlive = new Map<string, {
+    rollingScreenName: string;
+    originalScreenName: string;
+    pinnedDuration: number;
+    pinnedTime: number;
+}>();
+// rollingScreenName => originalScreenName
+let rollingScreens = new Map<string, string>();
+
 const runScreenCommand = measureWrap(async function runScreenCommand(config: {
     screenName: string;
     command: string;
+    rollingWindow: number | undefined;
 }) {
-    let screenName = config.screenName;
-    // C:/cygwin64/bin/tmux has-session -t myproj 2>/dev/null || C:/cygwin64/bin/tmux new-session -d -s myproj
     let prefix = getTmuxPrefix();
+    let screenName = config.screenName;
+
+    if (config.rollingWindow) {
+        let screens = await getScreenState();
+        let rollingObj = rollingKeepScreenAlive.get(screenName);
+        if (rollingObj) {
+            rollingObj.pinnedDuration = config.rollingWindow;
+        }
+        let existingScreen = screens.find(x => x.screenName === screenName);
+        if (existingScreen && !rollingObj) {
+            let nodeIdPath = os.homedir() + "/" + SERVICE_FOLDER + screenName + "/" + SERVICE_NODE_FILE_NAME;
+            let rollingFinalTime = Date.now() + config.rollingWindow;
+            if (fs.existsSync(nodeIdPath)) {
+                let nodeId = await fs.promises.readFile(nodeIdPath, "utf8");
+                await triggerRollingUpdate({
+                    nodeId,
+                    time: rollingFinalTime,
+                });
+            }
+            console.log(green(`Renaming screen ${screenName} to for rolling interval ${config.rollingWindow} at ${new Date().toLocaleString()}`));
+            let rollingScreenName = screenName + "-rolling";
+            await runPromise(`${prefix}tmux rename-window -t ${screenName} ${rollingScreenName}`);
+            rollingScreens.set(rollingScreenName, screenName);
+            rollingKeepScreenAlive.set(rollingScreenName, {
+                rollingScreenName,
+                originalScreenName: screenName,
+                pinnedDuration: config.rollingWindow,
+                pinnedTime: Date.now(),
+            });
+        }
+    }
+
     try {
         // Throw if it already exists
         await runPromise(`${prefix}tmux new -s ${screenName} -d`);
@@ -352,6 +395,7 @@ const runScreenCommand = measureWrap(async function runScreenCommand(config: {
                 await runScreenCommand({
                     screenName,
                     command: config.command,
+                    rollingWindow: config.rollingWindow,
                 });
                 return;
             }
@@ -520,7 +564,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                     continue;
                 }
 
-                console.log(`Resyncing service ${magenta(screenName)}`);
+                console.log(`Resyncing service ${magenta(screenName)}, with ${JSON.stringify(config.parameters)}`);
 
                 await fs.promises.writeFile(parameterPath, newParametersString);
 
@@ -533,6 +577,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 await runScreenCommand({
                     screenName,
                     command: config.parameters.command,
+                    rollingWindow: config.parameters.rollingWindow,
                 });
                 await delay(2000);
                 let newScreens = await getScreenState(false);
@@ -566,6 +611,20 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
 
     for (let { screenName } of screenState) {
         if (screenNamesUsed.has(screenName)) continue;
+        let rollingScreenRemainder = rollingScreens.get(screenName);
+        if (rollingScreenRemainder) {
+            let rollingInfo = rollingKeepScreenAlive.get(rollingScreenRemainder);
+            if (!rollingInfo) {
+                rollingScreens.delete(screenName);
+            }
+            if (rollingInfo && rollingInfo.pinnedTime + rollingInfo.pinnedDuration < Date.now()) {
+                console.log(green(`Killing rolling screen ${screenName} because it's expired at ${new Date().toLocaleString()}`));
+                rollingScreens.delete(screenName);
+                rollingKeepScreenAlive.delete(rollingScreenRemainder);
+                rollingInfo = undefined;
+            }
+            if (rollingInfo) continue;
+        }
         await killScreen({
             screenName,
         });

package/src/deployManager/machineController.ts

@@ -44,6 +44,12 @@ export function watchOnRollingUpdate(config: {
 }) {
     rollingUpdateWatchers.add(config.callback);
 }
+export async function triggerRollingUpdate(config: {
+    nodeId: string;
+    time: number;
+}) {
+    await OnServiceChange.nodes[config.nodeId].onRollingUpdate(config.time);
+}
 class OnServiceChangeBase {
     public async onServiceConfigChange() {
         await triggerServiceConfigChangeCallbacks();

package/src/deployManager/machineSchema.ts

@@ -78,9 +78,8 @@ export type ServiceConfig = {
         /** Not set by default, so we can setup the configuration before deploying it (or so we can undeploy easily without deleting it) */
         deploy?: boolean;
 
-
-        /** TODO: */
-        //rollingWindow?: number
+        /** Keep the instances of the service alive for this long after we start a new one. Only keeps the oldest alive, so multiple updates won't break things (or update the oldest one, so if the oldest one is bad, set this to 0 to make sure it dies immediately). */
+        rollingWindow?: number;
     };
     info: {
         title: string;

package/src/deployManager/spec.txt

@@ -1,15 +1,3 @@
-OH! the bootstrap root index file has CORS issues
-    - We didn't notice this before because the cached value always worked?
-
-The actual http registration isn't working? And our edgeNode file is so messy it's hard to see if it's there or not... ugh...
-
-
-8) Use a special service for the HTTP bootstrapper, and then have 2 others that are on other ports
-    --bootstraponly is added, and should work?
-
-9) Verify the bootstrap server can't be picked as the endpoint server
-
-
 9) Rolling service updates
     - Add rollingWindow to the definition
     - Set for public facing services (but not for scripts)
@@ -28,6 +16,10 @@ The actual http registration isn't working? And our edgeNode file is so messy it
         - 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.
+
+
 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?
         - Filled, but the total size will also depend on the maximum (to a degree), so it's very nice.