querysub 0.360.0 → 0.362.0

package/package.json

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

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -11,7 +11,7 @@ import { deepCloneJSON, nextId, sort } from "socket-function/src/misc";
 import { InputLabel } from "../../library-components/InputLabel";
 import { Button } from "../../library-components/Button";
 import { isDefined } from "../../misc";
-import { watchScreenOutput, stopWatchingScreenOutput } from "../machineController";
+import { watchScreenOutput, stopWatchingScreenOutput, MachineController } from "../machineController";
 import { getPathStr2 } from "../../path";
 import { ATag, Anchor } from "../../library-components/ATag";
 import { ScrollOnMount } from "../../library-components/ScrollOnMount";
@@ -38,6 +38,7 @@ export class ServiceDetailPage extends qreact.Component {
             data: t.type(""),
             callbackId: t.type(""),
         }),
+        isKillingRolling: t.type(false),
     });
 
 
@@ -103,6 +104,38 @@ export class ServiceDetailPage extends qreact.Component {
             await stopWatchingScreenOutput({ callbackId });
         });
     }
+
+    private async killAllRollingServices(config: ServiceConfig) {
+        Querysub.commit(() => {
+            this.state.isKillingRolling = true;
+        });
+
+        Querysub.onCommitFinished(async () => {
+            try {
+                let uniqueMachineIds = Array.from(new Set(config.machineIds));
+
+                for (let machineId of uniqueMachineIds) {
+                    let machineInfo = await MachineServiceController(SocketFunction.browserNodeId()).getMachineInfo.promise(machineId);
+                    if (!machineInfo) continue;
+
+                    let applyNodeId = machineInfo.applyNodeId;
+                    await MachineController(SocketFunction.browserNodeId()).killRollingServicesFromBrowser.promise({
+                        machineNodeId: applyNodeId,
+                        serviceKey: config.parameters.key,
+                    });
+                }
+            } catch (e: any) {
+                Querysub.localCommit(() => {
+                    this.state.saveError = `Error killing rolling services: ${e.message}`;
+                });
+            } finally {
+                Querysub.localCommit(() => {
+                    this.state.isKillingRolling = false;
+                });
+            }
+        });
+    }
+
     private async updateConfig(updatedConfig: ServiceConfig): Promise<void> {
         const selectedServiceId = selectedServiceIdParam.value;
         if (!selectedServiceId) return;
@@ -151,6 +184,28 @@ export class ServiceDetailPage extends qreact.Component {
         const configT = config;
         const hasUnsavedChanges = !!this.state.unsavedChanges;
 
+        let rollingServiceCount = 0;
+        if (config.parameters.rollingWindow) {
+            let uniqueMachineIds = Array.from(new Set(config.machineIds));
+            for (let machineId of uniqueMachineIds) {
+                try {
+                    let machineInfo = controller.getMachineInfo(machineId);
+                    if (!machineInfo) continue;
+
+                    let applyNodeId = machineInfo.applyNodeId;
+                    let rollingInfo = MachineController(SocketFunction.browserNodeId()).getRollingServiceInfoFromBrowser({
+                        machineNodeId: applyNodeId,
+                        serviceKey: config.parameters.key,
+                    });
+                    if (rollingInfo) {
+                        rollingServiceCount += rollingInfo.length;
+                    }
+                } catch (e: any) {
+                    console.error(`Error getting rolling service info for machine ${machineId}: ${e.message}`);
+                }
+            }
+        }
+
         // Sort machines by status and heartbeat
         let nextIndexes = new Map<string, number>();
         let machineStatuses = config.machineIds.map(machineId => {
@@ -432,6 +487,22 @@ export class ServiceDetailPage extends qreact.Component {
                     Poke
                 </button>
 
+                {configT.parameters.rollingWindow && rollingServiceCount > 0 && <button
+                    className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(0, 70, 90)}
+                    onClick={() => {
+                        void this.killAllRollingServices(config);
+                    }}
+                    disabled={this.state.isKillingRolling}
+                >
+                    {this.state.isKillingRolling ? "Killing..." : `💀 Kill ${rollingServiceCount} Rolling Service${rollingServiceCount === 1 ? "" : "s"}`}
+                </button>}
+
+                {configT.parameters.rollingWindow && <div>
+                    <div className={css.colorhsl(0, 50, 50).fontSize(14).fontWeight("bold")}>
+                        IMPORTANT! Service has a rolling window, so updates might not appear immediately.
+                    </div>
+                </div>}
+
                 {hasUnsavedChanges && <>
                     <Button
                         flavor="noui"

package/src/deployManager/components/ServicesListPage.tsx

@@ -136,7 +136,7 @@ export class ServicesListPage extends qreact.Component {
                                 </div>
                                 <div className={css.vbox(4)}>
                                     <div>Updated {formatDateJSX(config.info.lastUpdatedTime)} AGO</div>
-                                    {config.parameters.rollingWindow && <div>Rolling window: {formatTime(config.parameters.rollingWindow)}</div> || undefined}
+                                    {config.parameters.rollingWindow && <div className={css.colorhsl(0, 50, 50).fontSize(14).fontWeight("bold")}>Rolling window: {formatTime(config.parameters.rollingWindow)}</div> || undefined}
                                 </div>
                             </div>
                         </Anchor>

package/src/deployManager/machineApplyMainCode.ts

@@ -265,6 +265,45 @@ done`);
     })();
 }
 
+export async function getRollingServiceInfo(config: {
+    serviceKey: string;
+}): Promise<{ rollingScreenName: string; originalScreenName: string; expiresAt: number }[]> {
+    let rollingInfo: { rollingScreenName: string; originalScreenName: string; expiresAt: number }[] = [];
+
+    for (let [screenName, rolling] of rollingKeepScreenAlive) {
+        if (screenName.startsWith(config.serviceKey + "-")) {
+            rollingInfo.push({
+                rollingScreenName: rolling.rollingScreenName,
+                originalScreenName: rolling.originalScreenName,
+                expiresAt: rolling.pinnedTime + rolling.pinnedDuration,
+            });
+        }
+    }
+
+    return rollingInfo;
+}
+
+export async function killRollingServicesForService(config: {
+    serviceKey: string;
+}): Promise<void> {
+    let toDelete: string[] = [];
+
+    for (let [screenName, rolling] of rollingKeepScreenAlive) {
+        if (screenName.startsWith(config.serviceKey + "-")) {
+            console.log(red(`Explicitly killing rolling screen ${rolling.rollingScreenName} for service ${config.serviceKey}`));
+            await killScreen({
+                screenName: rolling.rollingScreenName,
+            });
+            rollingScreens.delete(rolling.rollingScreenName);
+            toDelete.push(screenName);
+        }
+    }
+
+    for (let screenName of toDelete) {
+        rollingKeepScreenAlive.delete(screenName);
+    }
+}
+
 
 const getTmuxPrefix = lazy(() => {
     if (os.platform() === "win32") {
@@ -734,6 +773,17 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 continue;
             }
         }
+
+        let rollingInfo = rollingKeepScreenAlive.get(screenName);
+        if (rollingInfo) {
+            console.log(red(`Service ${screenName} was disabled, killing associated rolling screen ${rollingInfo.rollingScreenName}`));
+            await killScreen({
+                screenName: rollingInfo.rollingScreenName,
+            });
+            rollingScreens.delete(rollingInfo.rollingScreenName);
+            rollingKeepScreenAlive.delete(screenName);
+        }
+
         await killScreen({
             screenName,
         });

package/src/deployManager/machineController.ts

@@ -5,7 +5,7 @@ import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { timeInMinute } from "socket-function/src/misc";
 import { assertIsManagementUser } from "../diagnostics/managementPages";
 import { isNode } from "typesafecss";
-import { streamScreenOutput } from "./machineApplyMainCode";
+import { streamScreenOutput, getRollingServiceInfo, killRollingServicesForService } from "./machineApplyMainCode";
 import { Querysub } from "../4-querysub/QuerysubController";
 import { getPathStr2 } from "../path";
 import { getGitURLLive, setGitRef } from "../4-deploy/git";
@@ -140,6 +140,36 @@ class MachineControllerBase {
         await runPromise("bash machine-startup.sh", { cwd: os.homedir(), detach: true });
     }
 
+    public async getRollingServiceInfo(config: {
+        serviceKey: string;
+    }): Promise<{ rollingScreenName: string; originalScreenName: string; expiresAt: number }[]> {
+        return await getRollingServiceInfo(config);
+    }
+
+    public async getRollingServiceInfoFromBrowser(config: {
+        machineNodeId: string;
+        serviceKey: string;
+    }): Promise<{ rollingScreenName: string; originalScreenName: string; expiresAt: number }[]> {
+        return await MachineController(config.machineNodeId).getRollingServiceInfo.promise({
+            serviceKey: config.serviceKey,
+        });
+    }
+
+    public async killRollingServices(config: {
+        serviceKey: string;
+    }): Promise<void> {
+        await killRollingServicesForService(config);
+    }
+
+    public async killRollingServicesFromBrowser(config: {
+        machineNodeId: string;
+        serviceKey: string;
+    }): Promise<void> {
+        await MachineController(config.machineNodeId).killRollingServices.promise({
+            serviceKey: config.serviceKey,
+        });
+    }
+
 }
 
 let forwardedCallbacks = new Map<string, string>();
@@ -152,6 +182,10 @@ export const MachineController = getSyncedController(SocketFunction.register(
         watchOtherScreenOutput: {},
         deployMachineFromBrowser: {},
         deployMachine: {},
+        getRollingServiceInfo: {},
+        getRollingServiceInfoFromBrowser: {},
+        killRollingServices: {},
+        killRollingServicesFromBrowser: {},
     }),
     () => ({
         hooks: [assertIsManagementUser],

package/src/deployManager/machineSchema.ts

@@ -33,7 +33,7 @@ export const SERVICE_NODE_FILE_NAME = "serviceNodeId.txt";
 export type MachineInfo = {
     machineId: string;
 
-    // Used to tell the apply tool to update it's configs now
+    // Used to talk to the apply script directly (ex, recheck the service config, kill the rolling nodes, etc)
     applyNodeId: string;
 
     heartbeat: number;

package/src/diagnostics/logs/lifeCycleAnalysis/lifeCycles.tsx

@@ -19,7 +19,17 @@ IMPORTANT! Now I am properly calling shutdown, so none of the streamed logs shou
 
 
 
-Logs still aren't appearing. Hmm...
+BUG: We aren't able to connect directly to the apply service? Hmm...
+
+0) Make a minor UI change, so we can see rolling nodes appear
+1) Disable, to ensure rolling nodes go away
+2) Re-enable
+3) Another minor UI change
+4) Use the new "kill rolling" so we can see a forced update
+
+
+BUG: Why are CYOA deploys not working!
+    I even disabled it, and nothing. It's still running. WTF...
 
 Hmm... why are not enough logs appearing?
     - We only have logs for server.ts? Wtf?
@@ -34,7 +44,7 @@ Hmm... why are not enough logs appearing?
     - Basically, just changes the code we're reading from multiple servers to select public servers instead, and then, of course, skip ourselves. 
 
 BUG: UGH... live logs for the remote server isn't working...
-    "new non-local WATCH"
+    new non-local WATCH
     - UGH... it being pending logs is annoying, as that's hard to debug locally...
     AH! Why do we have so few logs?