querysub 0.509.0 → 0.511.0

package/src/deployManager/machineSchema.ts

@@ -66,29 +66,37 @@ export type MachineInfo = {
 };
 
 
+export type ServiceParameters = {
+    /** MUST be unique, and clean enough to be used as the screen/tmux name, and folder name */
+    key: string;
+
+    /** There can be duplicate machine IDs which just means we apply multiple times on that machine, as `${key}-${index}-dply`, each with their own screen and folder. Part of the parameters so machine changes are released on the same schedule as everything else (but they never restart already-running instances, see restartParametersKey). Optional, as already deployed configs predate the field (treat missing as []). */
+    machineIds?: string[];
+
+    repoUrl: string;
+    gitRef: string;
+    command: string;
+    /** Allows forcing an update */
+    poke?: number;
+
+    /** Not set by default, so we can setup the configuration before deploying it (or so we can undeploy easily without deleting it) */
+    deploy?: boolean;
+
+    /** How long the new and old instances run simultaneously during a release. The new instances start at releaseTime - overlapTime, and the old instances are shut down at releaseTime. */
+    overlapTime?: number;
+
+    /** When these parameters go live. Until then machines keep running oldParameters. Absent (or in the past) means live now. */
+    releaseTime?: number;
+};
+
 export type ServiceConfig = {
     /** Just a random id to manage the service */
     serviceId: string;
 
-    /** There can be duplicate machine IDs which just means we apply multiple times on that machine, as `${key}-${index}-dply`, each with their own screen and folder */
-    machineIds: string[];
     /** When parameters update, we restart it (and when info updates, we do not) */
-    parameters: {
-        /** MUST be unique, and clean enough to be used as the screen/tmux name, and folder name */
-        key: string;
-
-        repoUrl: string;
-        gitRef: string;
-        command: string;
-        /** Allows forcing an update */
-        poke?: number;
-
-        /** Not set by default, so we can setup the configuration before deploying it (or so we can undeploy easily without deleting it) */
-        deploy?: boolean;
-
-        /** How long the new and old instances run simultaneously during a switchover. The new instances start at switchTime - overlapTime, and the old instances are shut down at switchTime. This is the default; each switchover can override it. */
-        overlapTime?: number;
-    };
+    parameters: ServiceParameters;
+    /** What machines keep running until parameters.releaseTime passes. Set automatically on every update (never by callers). */
+    oldParameters?: ServiceParameters;
     info: {
         title: string;
         notes: string;
@@ -96,25 +104,49 @@ export type ServiceConfig = {
     };
 };
 
-export const DEFAULT_OVERLAP_TIME = timeInMinute;
+export const DEFAULT_OVERLAP_TIME = timeInMinute * 10;
+
+/** The parameters machines should actually be running right now. */
+export function getLiveServiceParameters(config: ServiceConfig): ServiceParameters {
+    let releaseTime = config.parameters.releaseTime;
+    if (releaseTime && Date.now() < releaseTime && config.oldParameters) {
+        return config.oldParameters;
+    }
+    return config.parameters;
+}
+/** The full config as it is currently live (which parameters field that is depends on the current time). */
+export function getLiveServiceConfig(config: ServiceConfig): ServiceConfig {
+    return { ...config, parameters: getLiveServiceParameters(config), oldParameters: undefined };
+}
+export function stripReleaseState(config: ServiceConfig): ServiceConfig {
+    return { ...config, oldParameters: undefined, parameters: { ...config.parameters, releaseTime: undefined } };
+}
+/** The parts of the parameters that a running instance actually depends on. machineIds / releaseTime / overlapTime don't change what an instance runs, so changes to only them must never restart already-running instances (ex, adding a machine must not restart the existing machines). */
+export function restartParametersKey(parameters: ServiceParameters): string {
+    return JSON.stringify({ ...parameters, machineIds: undefined, releaseTime: undefined, overlapTime: undefined });
+}
+function getConfigMachineIds(config: ServiceConfig): string[] {
+    return [...new Set([...(config.parameters.machineIds || []), ...(config.oldParameters?.machineIds || [])])];
+}
+// Migrates records that stored machineIds at the top level of ServiceConfig (it now lives in parameters)
+function normalizeServiceConfig(config: ServiceConfig): ServiceConfig {
+    let legacyMachineIds = (config as unknown as { machineIds?: string[] }).machineIds;
+    if (legacyMachineIds) {
+        config.parameters.machineIds = config.parameters.machineIds || legacyMachineIds;
+        if (config.oldParameters) {
+            config.oldParameters.machineIds = config.oldParameters.machineIds || legacyMachineIds;
+        }
+        delete (config as unknown as { machineIds?: string[] }).machineIds;
+    }
+    return config;
+}
 
-export type ServiceSwitchover = {
-    serviceId: string;
-    /** When the old instances are shut down and the pending config becomes live */
-    switchTime: number;
-    /** The new instances start at switchTime - overlapTime */
-    overlapTime: number;
-    scheduledAt: number;
-};
 export type MachineConfig = {
     machineId: string;
     disabled: boolean;
 };
 export const machineInfos = archiveJSONT<MachineInfo>(() => nestArchives("machines/machine-heartbeats/", getArchivesBackblaze(getDomain())));
 export const serviceConfigs = archiveJSONT<ServiceConfig>(() => nestArchives("machines/service-configs/", getArchivesBackblaze(getDomain())));
-// Edits in the UI save here (still on disk), and only become live when a switchover is deployed / scheduled
-export const pendingServiceConfigs = archiveJSONT<ServiceConfig>(() => nestArchives("machines/service-configs-pending/", getArchivesBackblaze(getDomain())));
-export const serviceSwitchovers = archiveJSONT<ServiceSwitchover>(() => nestArchives("machines/service-switchovers/", getArchivesBackblaze(getDomain())));
 export const machineConfigs = archiveJSONT<MachineConfig>(() => nestArchives("machines/machine-configs/", getArchivesBackblaze(getDomain())));
 
 export type LaunchRecord = {
@@ -234,7 +266,8 @@ export class MachineServiceControllerBase {
         ])];
     }
     public async getServiceConfig(serviceId: string): Promise<ServiceConfig | undefined> {
-        return await serviceConfigs.get(serviceId);
+        let config = await serviceConfigs.get(serviceId);
+        return config && normalizeServiceConfig(config);
     }
 
     public async getMachineConfigList() {
@@ -278,14 +311,14 @@ export class MachineServiceControllerBase {
             throw new Error(`Service ${serviceId} already exists`);
         }
         await serviceConfigs.set(serviceId, config);
-        await this.notifyMachines(config.machineIds, []);
+        void this.notifyMachines(getConfigMachineIds(config), []);
     }
 
     public async setServiceConfigs(configs: ServiceConfig[]) {
         let newMachines = new Set<string>();
         let oldMachines = new Set<string>();
         let usedKeys = new Set<string>();
-        for (let config of configs) {
+        await Promise.all(configs.map(async config => {
             if (usedKeys.has(config.parameters.key)) {
                 console.warn(`Duplicate key: ${JSON.stringify(config.parameters.key)}. Not allowed, as this will break things! We are unduplicating the key.`);
                 config.parameters.key += `-${Math.random().toString().slice(2)}`;
@@ -299,19 +332,34 @@ export class MachineServiceControllerBase {
             if (!serviceConfig) {
                 throw new Error(`Service ${serviceId} does not exist`);
             }
+            normalizeServiceConfig(serviceConfig);
+
+            // The old parameters are whatever is live right now: the previous parameters if their release time passed, else the previous old parameters (an unreleased update was updated again, and machines just keep running what they were running).
+            if (config.parameters.releaseTime && Date.now() < config.parameters.releaseTime) {
+                let liveParameters = getLiveServiceParameters(serviceConfig);
+                if (JSON.stringify({ ...liveParameters, releaseTime: undefined }) === JSON.stringify({ ...config.parameters, releaseTime: undefined })) {
+                    // The parameters aren't changing, so there is nothing to release (machineIds / info changes apply immediately, only parameters wait for the release time)
+                    config.parameters.releaseTime = undefined;
+                    config.oldParameters = undefined;
+                } else {
+                    config.oldParameters = liveParameters;
+                }
+            } else {
+                config.oldParameters = undefined;
+            }
 
             await serviceConfigs.set(serviceId, config);
             // Only notify we were or are deployed. If it's not deployed, this will be ignored anyways.
             if (config.parameters.deploy || serviceConfig.parameters.deploy) {
-                for (let machineId of config.machineIds) {
+                for (let machineId of getConfigMachineIds(config)) {
                     newMachines.add(machineId);
                 }
-                for (let machineId of serviceConfig.machineIds) {
+                for (let machineId of getConfigMachineIds(serviceConfig)) {
                     oldMachines.add(machineId);
                 }
             }
-        }
-        await this.notifyMachines([...newMachines], [...oldMachines]);
+        }));
+        void this.notifyMachines([...newMachines], [...oldMachines]);
     }
 
     public async deleteServiceConfig(serviceId: string) {
@@ -323,62 +371,22 @@ export class MachineServiceControllerBase {
 
         // Remove the service config
         await serviceConfigs.delete(serviceId);
-        await pendingServiceConfigs.delete(serviceId);
-        await serviceSwitchovers.delete(serviceId);
-        await this.notifyMachines([], serviceConfig.machineIds);
+        void this.notifyMachines([], getConfigMachineIds(normalizeServiceConfig(serviceConfig)));
     }
 
-    /** Saves edits WITHOUT deploying them. They only take effect once a switchover is scheduled (scheduleSwitchover). */
-    public async setPendingServiceConfigs(configs: ServiceConfig[]) {
-        for (let config of configs) {
-            let serviceId = config.serviceId;
-            config.info.lastUpdatedTime = Date.now();
-            let serviceConfig = await serviceConfigs.get(serviceId);
-            if (!serviceConfig) {
-                throw new Error(`Service ${serviceId} does not exist`);
-            }
-            await pendingServiceConfigs.set(serviceId, config);
+    /** Cancels parameters that are scheduled to deploy (releaseTime in the future), reverting to what is currently live. Returns the cancelled config, so the caller can keep the edits (ex, back in the editor). */
+    public async cancelScheduledDeploy(serviceId: string): Promise<ServiceConfig> {
+        let record = await serviceConfigs.get(serviceId);
+        if (!record) {
+            throw new Error(`Service ${serviceId} does not exist`);
         }
-    }
-    public async getPendingServiceConfig(serviceId: string): Promise<ServiceConfig | undefined> {
-        return await pendingServiceConfigs.get(serviceId);
-    }
-    public async discardPendingServiceConfig(serviceId: string) {
-        await pendingServiceConfigs.delete(serviceId);
-        await serviceSwitchovers.delete(serviceId);
-    }
-
-    /** Deploys the pending config: the new instances start at switchTime - overlapTime, the old instances are told they will shut down at switchTime, and at switchTime the pending config becomes live. */
-    public async scheduleSwitchover(config: {
-        serviceId: string;
-        switchTime: number;
-        overlapTime: number;
-    }) {
-        let pending = await pendingServiceConfigs.get(config.serviceId);
-        if (!pending) {
-            throw new Error(`No pending config for service ${config.serviceId}. Save changes first, then deploy them.`);
-        }
-        let live = await serviceConfigs.get(config.serviceId);
-        if (!live) {
-            throw new Error(`Service ${config.serviceId} does not exist`);
-        }
-        await serviceSwitchovers.set(config.serviceId, {
-            serviceId: config.serviceId,
-            switchTime: config.switchTime,
-            overlapTime: config.overlapTime,
-            scheduledAt: Date.now(),
-        });
-        await this.notifyMachines([...new Set([...live.machineIds, ...pending.machineIds])], []);
-    }
-    public async cancelSwitchover(serviceId: string) {
-        let live = await serviceConfigs.get(serviceId);
-        await serviceSwitchovers.delete(serviceId);
-        if (live) {
-            await this.notifyMachines(live.machineIds, []);
+        normalizeServiceConfig(record);
+        if (!record.parameters.releaseTime || Date.now() >= record.parameters.releaseTime || !record.oldParameters) {
+            throw new Error(`Service ${serviceId} has no scheduled deploy to cancel (it may have already gone live)`);
         }
-    }
-    public async getServiceSwitchover(serviceId: string): Promise<ServiceSwitchover | undefined> {
-        return await serviceSwitchovers.get(serviceId);
+        await serviceConfigs.set(serviceId, { ...record, parameters: record.oldParameters, oldParameters: undefined });
+        void this.notifyMachines(getConfigMachineIds(record), []);
+        return stripReleaseState(record);
     }
     public async getServiceConfigType(): Promise<string> {
         return extractType(module, "ServiceConfig");
@@ -552,10 +560,14 @@ export async function getEffectiveServiceConfigs(): Promise<ServiceConfig[]> {
         }
     }
 
-    return configs.map(config => ({
-        ...config,
-        machineIds: config.machineIds.filter(machineId => !disabledMachineIds.has(machineId)),
-    }));
+    return configs.map(config => {
+        normalizeServiceConfig(config);
+        config.parameters.machineIds = (config.parameters.machineIds || []).filter(machineId => !disabledMachineIds.has(machineId));
+        if (config.oldParameters) {
+            config.oldParameters.machineIds = (config.oldParameters.machineIds || []).filter(machineId => !disabledMachineIds.has(machineId));
+        }
+        return config;
+    });
 }
 
 let deployWatchers = new Set<DeployProgress>();
@@ -607,12 +619,7 @@ export const MachineServiceController = getSyncedController(
             setMachineConfig: {},
             addServiceConfig: {},
             setServiceConfigs: {},
-            setPendingServiceConfigs: {},
-            getPendingServiceConfig: {},
-            discardPendingServiceConfig: {},
-            scheduleSwitchover: {},
-            cancelSwitchover: {},
-            getServiceSwitchover: {},
+            cancelScheduledDeploy: {},
             getServiceConfigType: {},
             deleteServiceConfig: {},
             getGitInfo: {},
@@ -637,11 +644,8 @@ export const MachineServiceController = getSyncedController(
             setMachineConfig: ["MachineConfig", "MachineConfigList"],
             addServiceConfig: ["ServiceConfig", "ServiceConfigList"],
             setServiceConfigs: ["ServiceConfig"],
-            setPendingServiceConfigs: ["PendingServiceConfig"],
-            discardPendingServiceConfig: ["PendingServiceConfig", "ServiceSwitchover"],
-            scheduleSwitchover: ["ServiceSwitchover"],
-            cancelSwitchover: ["ServiceSwitchover"],
-            deleteServiceConfig: ["ServiceConfig", "ServiceConfigList", "PendingServiceConfig", "ServiceSwitchover"],
+            cancelScheduledDeploy: ["ServiceConfig"],
+            deleteServiceConfig: ["ServiceConfig", "ServiceConfigList"],
             commitPushService: ["gitInfo", "ServiceConfig"],
             commitPushAndPublishQuerysub: ["gitInfo", "ServiceConfig"],
             deployFunctions: ["gitInfo"],
@@ -653,8 +657,6 @@ export const MachineServiceController = getSyncedController(
             getMachineConfig: ["MachineConfig"],
             getServiceList: ["ServiceConfigList"],
             getServiceConfig: ["ServiceConfig"],
-            getPendingServiceConfig: ["PendingServiceConfig"],
-            getServiceSwitchover: ["ServiceSwitchover"],
             getGitInfo: ["gitInfo"],
             getPendingFunctions: ["gitInfo"],
             getLiveFunctions: ["gitInfo"],

package/src/diagnostics/logs/errorNotifications2/ErrorNotificationPage.tsx

@@ -141,7 +141,7 @@ export class LogDatumRenderer extends qreact.Component<{
                     <div>{formatDateTime(datum.time)}</div>
                 </div>
                 {datum.__machineId && <MachineThreadInfo machineId={datum.__machineId} threadId={datum.__threadId} />}
-                <span className={css.ellipsis.flexFillWidth.colorhsl(0, 50, 50).boldStyle}>{mainMessage}</span>
+                <span className={css.ellipsis.flexFillWidth.colorhsl(0, 50, 50).boldStyle} title={mainMessage}>{mainMessage}</span>
             </div>
 
             {!this.props.inlineMode && this.state.expanded && (

package/src/library-components/TypedConfigEditor.tsx

@@ -34,11 +34,12 @@ let nextSeqNum = Math.floor(Date.now() / 1000);
 export class TypedConfigEditor extends qreact.Component<TypedConfigEditorProps> {
     state = t.state({
         editorReady: t.type(false),
-        currentValue: t.type<any>(undefined)
     });
 
     private editor: any = null;
     private model: any = null;
+    // The last value either typed into the editor or pushed into it (as 4-space JSON). A plain field (NOT state), so comparing/updating it can never trigger re-renders.
+    private lastKnownValueStr = "";
     private uniqueId = nextSeqNum++;
 
     private typeName = `Type${this.uniqueId}`;
@@ -83,10 +84,9 @@ export class TypedConfigEditor extends qreact.Component<TypedConfigEditorProps>
         );
     }
 
-    private updateEditorValue(value: any): void {
+    private updateEditorContent(valueStr: string): void {
         if (!this.model) return;
 
-        const valueStr = JSON.stringify(value, null, 4);
         const content = `const ${this.valueName}: ${this.typeName} = ${valueStr}`;
 
         // Only update if content has changed to avoid cursor jumping
@@ -96,15 +96,7 @@ export class TypedConfigEditor extends qreact.Component<TypedConfigEditorProps>
     }
 
     componentDidMount(): void {
-        this.state.currentValue = this.props.value;
-    }
-
-    componentDidUpdate(prevProps: TypedConfigEditorProps): void {
-        // Update editor if value changed from props
-        if (this.props.value !== prevProps.value && this.props.value !== this.state.currentValue) {
-            this.state.currentValue = this.props.value;
-            this.updateEditorValue(this.props.value);
-        }
+        this.lastKnownValueStr = JSON.stringify(this.props.value ?? null, null, 4);
     }
 
     componentWillUnmount(): void {
@@ -121,6 +113,15 @@ export class TypedConfigEditor extends qreact.Component<TypedConfigEditorProps>
         let valueName = this.valueName;
         let typeDefinition = `type ${typeName} = ${this.props.typeDefinition}`;
 
+        // qreact has no componentDidUpdate, so external value changes (ex, the parent discarding edits) are detected here and pushed into the editor. Changes the user typed round-trip through onValueChange into lastKnownValueStr, so they compare equal and never clobber the editor.
+        let propsValueStr = JSON.stringify(this.props.value ?? null, null, 4);
+        if (this.state.editorReady && this.lastKnownValueStr !== propsValueStr) {
+            this.lastKnownValueStr = propsValueStr;
+            Querysub.onCommitFinished(() => {
+                this.updateEditorContent(propsValueStr);
+            });
+        }
+
         return <div
             key={"Editor-" + this.uniqueId}
             ref2={async element => {
@@ -149,7 +150,7 @@ export class TypedConfigEditor extends qreact.Component<TypedConfigEditorProps>
                     this.model = window.monaco.editor.getModel(configUri);
                     if (this.model) {
                         // Update existing model content
-                        this.updateEditorValue(propsValue);
+                        this.updateEditorContent(valueStr);
                     } else {
                         // Create new model
                         this.model = window.monaco.editor.createModel(
@@ -176,9 +177,7 @@ export class TypedConfigEditor extends qreact.Component<TypedConfigEditorProps>
                             try {
                                 // Try to parse the JSON
                                 const parsedValue = JSON.parse(configMatch[1]);
-                                Querysub.localCommit(() => {
-                                    this.state.currentValue = parsedValue;
-                                });
+                                this.lastKnownValueStr = JSON.stringify(parsedValue, null, 4);
 
                                 Querysub.commit(() => {
                                     this.props.onValueChange?.(parsedValue);
@@ -189,7 +188,7 @@ export class TypedConfigEditor extends qreact.Component<TypedConfigEditorProps>
                         }
                     });
 
-                    Querysub.localCommit(() => {
+                    Querysub.commit(() => {
                         this.state.editorReady = true;
                     });
                 });

package/src/misc.ts

@@ -1,5 +1,6 @@
 import { canHaveChildren } from "socket-function/src/types";
 import { delay } from "socket-function/src/batching";
+import { timeInDay, timeInSecond } from "socket-function/src/misc";
 
 // TIMING: About 20MB/s
 export function createRandomText(count: number): string {
@@ -197,6 +198,35 @@ export function maybeUndefined<T>(value: T): T | undefined {
     return value;
 }
 
+const PRECISE_TIMEOUT_MAX_SLEEP = timeInDay;
+const PRECISE_TIMEOUT_MIN_SLEEP = timeInSecond;
+/** Fires the callback at the given absolute time. A single setTimeout drifts over long waits (and overflows past ~24.8 days), so this re-arms, sleeping 90% of the remaining time each wake (re-reading the clock), and so hits the target within about a second even over multi-day waits. Returns a cancel function. */
+export function setPreciseTimeout(config: {
+    time: number;
+    callback: () => void;
+}): () => void {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let cancelled = false;
+    const arm = () => {
+        if (cancelled) return;
+        let remaining = config.time - Date.now();
+        if (remaining <= 0) {
+            timer = undefined;
+            config.callback();
+            return;
+        }
+        timer = setTimeout(arm, Math.min(Math.max(remaining * 0.9, PRECISE_TIMEOUT_MIN_SLEEP), PRECISE_TIMEOUT_MAX_SLEEP));
+    };
+    arm();
+    return () => {
+        cancelled = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+}
+
 /** Runs `callback` for every item, but staggers the calls evenly across `totalTime` instead of
  *      firing them all at once, and awaits all of them before returning. Used inside a poll loop
  *      (with totalTime = the poll interval) so fanning out to many nodes doesn't spike — otherwise