querysub 0.359.0 → 0.361.0

package/package.json

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

package/src/config.ts

@@ -22,7 +22,12 @@ let yargObj = parseArgsFactory()
     // TODO: The bootstrapper is a single file. Maybe we shouldn't run the entire service just for that. Although... maybe it's fine, as services are light?
     .option("bootstraponly", { type: "boolean", desc: "Don't register as an edge node, so we serve the bootstrap files, but we don't need up to date code because we are not used for endpoints or the UI." })
     .option("notifyemails", { type: "array", desc: "The emails to notify when errors occur." })
-    .option("diskaudit", { type: "boolean", desc: "Track all audit logs to disk. This might end up writing A LOT of data." })
+    .option("diskaudit", {
+        type: "boolean",
+        // NOTE: I wanna see how long I can keep this on for. Eventually it's gonna become a problem and we're gonna have to turn it off. But for testing it's certainly useful as we don't know exactly what is gonna cause a problem. But it probably will be synchronization related, and every server does synchronization.
+        default: true,
+        desc: "Track all audit logs to disk. This might end up writing A LOT of data."
+    })
     .argv
     ;
 type QuerysubConfig = {

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,37 @@ 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(applyNodeId).killRollingServices.promise({
+                        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 +183,27 @@ 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(applyNodeId).getRollingServiceInfo({
+                        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 +485,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,18 @@ 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 killRollingServices(config: {
+        serviceKey: string;
+    }): Promise<void> {
+        await killRollingServicesForService(config);
+    }
+
 }
 
 let forwardedCallbacks = new Map<string, string>();
@@ -152,6 +164,8 @@ export const MachineController = getSyncedController(SocketFunction.register(
         watchOtherScreenOutput: {},
         deployMachineFromBrowser: {},
         deployMachine: {},
+        getRollingServiceInfo: {},
+        killRollingServices: {},
     }),
     () => ({
         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/IndexedLogs/LogViewer3.tsx

@@ -23,6 +23,7 @@ import { PUBLIC_MOVE_THRESHOLD } from "./BufferIndexLogsOptimizationConstants";
 import { atomic } from "../../../2-proxy/PathValueProxyWatcher";
 import { errorToUndefined } from "querysub/src/errors";
 import { IndexedLogResults, createEmptyIndexedLogResults } from "./BufferIndexHelpers";
+import { TimeFilePath } from "./TimeFileTree";
 
 let searchText = new URLParam("searchText", "");
 let readLiveData = new URLParam("readLiveData", false);
@@ -435,6 +436,19 @@ export class LogViewer3 extends qreact.Component {
             this.state.paths = allPaths;
             this.state.loadingPaths = false;
         });
+        return allPaths;
+    }
+
+    async updatePaths() {
+        let prevPaths = this.getPaths();
+        let newPaths = await this.loadPaths();
+        Querysub.commitLocal(() => {
+            function getHash(path: TimeFilePath): string {
+                return path.threadId + "_" + path.machineId;
+            }
+            let keep = new Set(prevPaths.map(getHash));
+            this.state.paths = newPaths?.filter(x => keep.has(getHash(x))) || [];
+        });
     }
 
     cancel = async () => {
@@ -798,11 +812,16 @@ export class LogViewer3 extends qreact.Component {
                         <Button
                             flavor="large"
                             onClick={() => void this.loadPaths()}
-                            hue={120}
+                            hue={this.state.paths.length ? 200 : 120}
                         >
-                            Preview Files
+                            {this.state.paths.length && "Reset Files" || "Preview Files"}
                         </Button>
                     )}
+                    {this.state.paths && !savedPathsURL.value &&
+                        <Button flavor="large" hue={120} onClick={() => void this.updatePaths()}>
+                            Update Files
+                        </Button>
+                    }
                     {savedPathsURL.value && (
                         <Button
                             flavor="large"

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

@@ -19,8 +19,13 @@ IMPORTANT! Now I am properly calling shutdown, so none of the streamed logs shou
 
 
 
-OH! The archives have to be put in the home folder. They aren't?
+BUG: Fix it so we properly kill rolling screens when we disable a service
 
+TODO: Show rolling services somewhere
+
+
+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?
@@ -35,7 +40,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?