querysub 0.563.0 → 0.565.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.563.0",
+  "version": "0.565.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -71,7 +71,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "sliftutils": "^1.7.41",
+    "sliftutils": "^1.7.43",
     "socket-function": "^1.2.26",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",

package/src/deployManager/components/ProcessesView.tsx

@@ -167,6 +167,12 @@ export class ProcessesView extends qreact.Component<{
     serviceId?: string;
 }> {
     render() {
+        // Callers hand us one entry per service instance, so a machine running several instances arrives several times. Each machine's processes are listed once, whatever it is running.
+        let machines = new Map<string, { machineId: string; applyNodeId: string }>();
+        for (let machine of this.props.machines) {
+            if (machines.has(machine.machineId)) continue;
+            machines.set(machine.machineId, machine);
+        }
         return <div className={css.vbox(14).fillWidth}>
             <div className={css.hbox(10).alignItems("center")}>
                 <h3 className={css.flexGrow(1)}>Processes</h3>
@@ -176,7 +182,7 @@ export class ProcessesView extends qreact.Component<{
                     Invalidate
                 </Button>
             </div>
-            {this.props.machines.map(machine => <MachineProcesses
+            {[...machines.values()].map(machine => <MachineProcesses
                 key={machine.machineId}
                 machineId={machine.machineId}
                 applyNodeId={machine.applyNodeId}

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -35,10 +35,6 @@ export class ServiceDetailPage extends qreact.Component {
         expandedErrors: t.lookup({
             expanded: t.type(false)
         }),
-        // Milliseconds; 0 means no scheduled time picked yet (use Deploy Now instead)
-        switchTime: t.number(0),
-        // Seconds until the release goes live; 0 means use the default (DEFAULT_OVERLAP_TIME)
-        releaseDelayOverride: t.number(0),
         // Seconds the old instances outlive the release; 0 means use the default (DEFAULT_OVERLAP_TIME). The no-overlap deploy buttons are how you deploy with an actual 0.
         overlapOverride: t.number(0),
     });
@@ -64,8 +60,6 @@ export class ServiceDetailPage extends qreact.Component {
                 await MachineServiceController(SocketFunction.browserNodeId()).setServiceConfigs.promise([deployConfig]);
                 Querysub.commit(() => {
                     this.state.editorState = stripReleaseState(deployConfig);
-                    this.state.switchTime = 0;
-                    this.state.releaseDelayOverride = 0;
                     this.state.overlapOverride = 0;
                 });
             } finally {
@@ -93,16 +87,16 @@ export class ServiceDetailPage extends qreact.Component {
         modal = showModal({
             content: <div className={css.fixed.pos(0, 0).size("100vw", "100vh").hsla(0, 0, 0, 0.5).display("flex").alignItems("center").justifyContent("center")}>
                 <div className={css.vbox(12).pad2(20).hsl(0, 0, 12).colorhsl(0, 0, 90).bord2(0, 0, 40) + " keepModalsOpen"}>
-                    <div className={css.boldStyle.fontSize(16)}>⚡ Force deploy now?</div>
+                    <div className={css.boldStyle.fontSize(16)}>🚀 Deploy?</div>
                     <div>{deployConfig.parameters.overlapTime
-                        ? `This config becomes live immediately. The old instances keep running for ${formatTime(deployConfig.parameters.overlapTime)} before shutting down.`
-                        : "This config becomes live immediately. The old instances are shut down right away, with no overlap."}</div>
+                        ? `This config goes live now. The old instances keep running for ${formatTime(deployConfig.parameters.overlapTime)} before shutting down.`
+                        : "This config goes live now. The old instances are shut down as soon as the new ones are up, so anything still connected to them is dropped."}</div>
                     <div className={css.hbox(10)}>
                         <Button hue={0} onClick={() => {
                             modal && modal.close();
                             deployConfig.parameters.releaseTime = Date.now();
                             this.deployConfig(deployConfig);
-                        }}>⚡ Force Deploy Now</Button>
+                        }}>🚀 Deploy</Button>
                         <Button onClick={() => modal && modal.close()}>Cancel</Button>
                     </div>
                 </div>
@@ -642,70 +636,39 @@ export class ServiceDetailPage extends qreact.Component {
                         <span title={`${configCompareKey(config)} !== ${configCompareKey(deployedConfig)}`}>Only the title / notes changed, so this saves immediately</span>
                     </div>;
                 }
-                let releaseDelaySeconds = this.state.releaseDelayOverride || Math.round(DEFAULT_OVERLAP_TIME / timeInSecond);
-                let releaseDelay = releaseDelaySeconds * timeInSecond;
                 let overlapSeconds = this.state.overlapOverride || Math.round(DEFAULT_OVERLAP_TIME / timeInSecond);
                 let overlap = overlapSeconds * timeInSecond;
-                let scheduledTime = this.state.switchTime;
-                const makeDeployConfig = (releaseTime: number, overlapTime = overlap) => {
+                // A deploy always goes live now. The overlap is what keeps the service up: the old instances keep running for it, so connections have somewhere to go while clients move across.
+                const makeDeployConfig = (overlapTime = overlap) => {
                     let deployConfig = deepCloneJSON(config);
-                    deployConfig.parameters.releaseTime = releaseTime;
+                    deployConfig.parameters.releaseTime = Date.now();
                     deployConfig.parameters.overlapTime = overlapTime;
                     return deployConfig;
                 };
-                // The switch time is inferred from the release delay, unless one is explicitly set
-                let effectiveSwitchTime = scheduledTime || now + releaseDelay;
                 return <div className={css.vbox(10).pad2(12).fillWidth.bord2(45, 70, 45).hsl(45, 60, 95)}>
                     <div className={css.boldStyle.fontSize(15)}>
                         ✏️ Edited (only in this browser, until deployed)
                     </div>
                     <ParametersDiff base={liveParameters} next={config.parameters} />
-                    <div className={css.hbox(12).wrap}>
+                    <div className={css.hbox(12).wrap.alignItems("center")}>
                         <button
                             className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(120, 70, 85).fontWeight("bold")}
                             disabled={this.state.isDeploying}
+                            title="Deploys now; the old instances keep running for the overlap before shutting down"
                             onClick={() => {
-                                this.deployConfig(makeDeployConfig(scheduledTime || Date.now() + releaseDelay));
+                                this.confirmForceDeployNow(makeDeployConfig());
                             }}>
-                            {this.state.isDeploying && "⏳ Scheduling..." || scheduledDeploy && "🔁 Replace Scheduled Deploy" || "🚀 Schedule Deploy"}
+                            {this.state.isDeploying && "⏳ Deploying..." || "🚀 Deploy"}
                         </button>
                         <button
-                            className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(35, 70, 85)}
+                            className={css.pad2(12, 8).button.bord2(0, 90, 30).hsl(0, 85, 65).colorhsl(0, 0, 100).fontWeight("bold")}
                             disabled={this.state.isDeploying}
-                            title="Deploys with the configured release delay, but the old instances shut down immediately at release time (overlap of 0)"
+                            title="Deploys now AND shuts the old instances down as soon as the new ones are up (overlap of 0)"
                             onClick={() => {
-                                this.deployConfig(makeDeployConfig(scheduledTime || Date.now() + releaseDelay, 0));
+                                this.confirmForceDeployNow(makeDeployConfig(0));
                             }}>
                             Deploy, No Overlap
                         </button>
-                        <div className={css.opacity(scheduledTime && 1 || 0.5)}>
-                            <InputLabel
-                                label="Switch at"
-                                isDatetime
-                                value={effectiveSwitchTime}
-                                onChangeValue={value => {
-                                    this.state.switchTime = Number(value) || 0;
-                                }}
-                            />
-                        </div>
-                        <span>(in {formatTime(effectiveSwitchTime - now)})</span>
-                        {!!scheduledTime && <button
-                            className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(0, 0, 90)}
-                            onClick={() => {
-                                this.state.switchTime = 0;
-                            }}>
-                            ↺ Reset to delay-based time
-                        </button>}
-                        <div className={css.opacity(scheduledTime && 0.5 || 1)}>
-                            <InputLabel
-                                label="Release in (seconds)"
-                                integer
-                                value={releaseDelaySeconds}
-                                onChangeValue={value => {
-                                    this.state.releaseDelayOverride = Number(value) || 0;
-                                }}
-                            />
-                        </div>
                         <InputLabel
                             label="Overlap (seconds)"
                             integer
@@ -715,29 +678,6 @@ export class ServiceDetailPage extends qreact.Component {
                             }}
                         />
                     </div>
-                    {!!scheduledTime && scheduledTime <= now && <span className={css.colorhsl(0, 85, 45).fontWeight("bold")}>
-                        ⚠️ The switch time is in the past — deploying switches immediately
-                    </span>}
-                    <div className={css.hbox(8)}>
-                        <button
-                            className={css.pad2(12, 8).button.bord2(45, 80, 35).hsl(45, 85, 82)}
-                            disabled={this.state.isDeploying}
-                            title="Deploys immediately; the old instances keep running for their configured overlap before shutting down"
-                            onClick={() => {
-                                this.confirmForceDeployNow(makeDeployConfig(Date.now()));
-                            }}>
-                            ⚡ Force Deploy Now
-                        </button>
-                        <button
-                            className={css.pad2(12, 8).button.bord2(0, 90, 30).hsl(0, 85, 65).colorhsl(0, 0, 100).fontWeight("bold")}
-                            disabled={this.state.isDeploying}
-                            title="Deploys immediately AND shuts down the old instances immediately (overlap of 0)"
-                            onClick={() => {
-                                this.confirmForceDeployNow(makeDeployConfig(Date.now(), 0));
-                            }}>
-                            ⚡ Force Deploy Now, No Overlap
-                        </button>
-                    </div>
                 </div>;
             })()}
 

package/src/deployManager/components/deployButtons.tsx

@@ -77,21 +77,16 @@ export class UpdateButtons extends qreact.Component<{
     state = t.state({
         isDeploying: t.type(false),
     });
-    // Deploys all outdated services to latestRef. "scheduled" delays the release by the configured overlap (an unrelated value, but a reasonable delay); "now" releases immediately but the old instances still run out their configured overlap; "nowNoOverlap" releases immediately AND shuts the old instances down immediately.
-    private deployAll(outdatedServices: ServiceConfig[], latestRef: string, mode: "scheduled" | "now" | "nowNoOverlap") {
+    // Deploys all outdated services to latestRef, always immediately. The overlap is what keeps the service up - the old instances keep running for it, so connections have somewhere to go while clients move across. noOverlap kills them at once instead.
+    private deployAll(outdatedServices: ServiceConfig[], latestRef: string, noOverlap: boolean) {
         this.state.isDeploying = true;
         // Props are synchronized state, so everything the async work needs is cloned into plain locals HERE, in the synced part
         let toDeploy = outdatedServices.map(service => {
             let updated = deepCloneJSON(service);
             updated.parameters.gitRef = latestRef;
-            if (mode === "scheduled") {
-                let overlap = updated.parameters.overlapTime ?? DEFAULT_OVERLAP_TIME;
-                updated.parameters.releaseTime = Date.now() + overlap;
-            } else {
-                updated.parameters.releaseTime = Date.now();
-                if (mode === "nowNoOverlap") {
-                    updated.parameters.overlapTime = 0;
-                }
+            updated.parameters.releaseTime = Date.now();
+            if (noOverlap) {
+                updated.parameters.overlapTime = 0;
             }
             return updated;
         });
@@ -112,14 +107,14 @@ export class UpdateButtons extends qreact.Component<{
             content: <div className={css.vbox(12).pad2(20)}>
                 <div className={css.boldStyle.fontSize(16)}>⚡ Deploy all {outdatedServices.length} services now?</div>
                 <div>{noOverlap
-                    ? "All services release immediately AND their old instances shut down immediately (overlap of 0)."
-                    : "All services release immediately. Their old instances keep running for their configured overlap before shutting down."}</div>
+                    ? "The old instances are shut down as soon as the new ones are up (overlap of 0), so anything still connected to them is dropped."
+                    : "The old instances keep running for their configured overlap before shutting down, so connections have somewhere to go while clients move across."}</div>
                 <div className={css.hbox(10)}>
                     <button
                         className={css.pad2(12, 8).button + (noOverlap && css.bord2(0, 90, 30).hsl(0, 85, 65).colorhsl(0, 0, 100).fontWeight("bold") || css.bord2(45, 80, 35).hsl(45, 85, 82))}
                         onClick={() => {
                             modal && modal.close();
-                            this.deployAll(outdatedServices, latestRef, noOverlap ? "nowNoOverlap" : "now");
+                            this.deployAll(outdatedServices, latestRef, noOverlap);
                         }}>
                         ⚡ Deploy Now
                     </button>
@@ -188,8 +183,9 @@ export class UpdateButtons extends qreact.Component<{
                 <button
                     className={buttonStyle.hsl(120, 70, 90)}
                     disabled={this.state.isDeploying}
+                    title="Deploys now; the old instances keep running for their configured overlap before shutting down"
                     onClick={() => {
-                        this.deployAll(outdatedServices, gitInfo.latestRef, "scheduled");
+                        this.confirmDeployAllNow(outdatedServices, gitInfo.latestRef, false);
                     }}
                 >
                     <div>
@@ -204,28 +200,16 @@ export class UpdateButtons extends qreact.Component<{
                         <RenderGitRefInfo gitRef={ref} />
                     </div>)}
                 </button>
-                <button
-                    className={buttonStyle.hsl(45, 85, 82)}
-                    disabled={this.state.isDeploying}
-                    title="Deploys immediately; the old instances keep running for their configured overlap before shutting down"
-                    onClick={() => {
-                        this.confirmDeployAllNow(outdatedServices, gitInfo.latestRef, false);
-                    }}
-                >
-                    <div>
-                        {bigEmoji("⚡")} <span>{this.state.isDeploying && "⏳ Deploying..." || `Deploy All (${outdatedServices.length}) Now (no delay)`}</span>
-                    </div>
-                </button>
                 <button
                     className={buttonStyle.hsl(0, 85, 70)}
                     disabled={this.state.isDeploying}
-                    title="Deploys immediately AND shuts down the old instances immediately (overlap of 0)"
+                    title="Deploys now AND shuts the old instances down as soon as the new ones are up (overlap of 0)"
                     onClick={() => {
                         this.confirmDeployAllNow(outdatedServices, gitInfo.latestRef, true);
                     }}
                 >
                     <div>
-                        {bigEmoji("⚡")} <span>{this.state.isDeploying && "⏳ Deploying..." || `Deploy All (${outdatedServices.length}) Now (no delay, no overlap)`}</span>
+                        {bigEmoji("⚡")} <span>{this.state.isDeploying && "⏳ Deploying..." || `Deploy All (${outdatedServices.length}), No Overlap`}</span>
                     </div>
                 </button>
             </>}