querysub 0.694.0 → 0.696.0

package/package.json

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

@@ -595,19 +595,6 @@ export class ServiceDetailPage extends qreact.Component {
                         Old instances shut down in {formatTime(scheduledDeploy.switchTime + scheduledDeploy.overlapTime - now)} ({formatDateTimeDetailed(scheduledDeploy.switchTime + scheduledDeploy.overlapTime)})
                     </div>
                     <div className={css.hbox(8)}>
-                        <button
-                            className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(0, 70, 90)}
-                            onClick={() => {
-                                this.runControllerAction(async () => {
-                                    let cancelled = await controller.cancelScheduledDeploy.promise(selectedServiceId);
-                                    // Keep the cancelled changes in the editor, so they aren't lost (Discard Changes drops them)
-                                    Querysub.commit(() => {
-                                        this.state.editorState = cancelled;
-                                    });
-                                });
-                            }}>
-                            Cancel Scheduled Deploy
-                        </button>
                         <button
                             className={css.pad2(12, 8).button.bord2(45, 80, 35).hsl(45, 85, 82)}
                             disabled={this.state.isDeploying}

package/src/deployManager/components/deployButtons.tsx

@@ -106,22 +106,59 @@ export function confirmNoOverlapDeploy(actionLabel: string, onConfirm: () => voi
     });
 }
 
+const CONFIRM_LIST_MAX_HEIGHT = 220;
+
+/** Deploying every outdated service restarts all of them at once, which is most of the cluster — worth naming what is about to restart before it happens. */
+class DeployAllConfirmModal extends qreact.Component<{ titles: string[]; latestRef: string; onConfirm: () => void }> {
+    render() {
+        let count = this.props.titles.length;
+        return <div className={css.vbox(14).maxWidth(560)}>
+            <div className={css.fontSize(18).boldStyle}>Deploy {count} service{count === 1 && "" || "s"}?</div>
+            <div>
+                Each one restarts onto {this.props.latestRef.slice(0, 6)}. The old instances keep running for {formatTime(DEFAULT_OVERLAP_TIME)} before shutting down, so there is somewhere for connections to go while clients move across.
+            </div>
+            <div className={css.vbox(2).fillWidth.maxHeight(CONFIRM_LIST_MAX_HEIGHT).overflowAuto}>
+                {this.props.titles.map(title => <div>{title}</div>)}
+            </div>
+            <div className={css.hbox(10)}>
+                <button
+                    className={buttonStyle.hsl(120, 70, 90)}
+                    onClick={() => {
+                        closeAllModals();
+                        this.props.onConfirm();
+                    }}
+                >
+                    Deploy & Restart All ({count})
+                </button>
+                <button className={buttonStyle.hsl(0, 0, 90)} onClick={() => closeAllModals()}>
+                    Cancel
+                </button>
+            </div>
+        </div>;
+    }
+}
+export function confirmDeployAll(config: { titles: string[]; latestRef: string; onConfirm: () => void }) {
+    showFullscreenModal({
+        content: <DeployAllConfirmModal titles={config.titles} latestRef={config.latestRef} onConfirm={config.onConfirm} />,
+    });
+}
+
 export class UpdateButtons extends qreact.Component<{
     services: ServiceConfig[];
 }> {
     state = t.state({
         isDeploying: t.type(false),
     });
-    // 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) {
+    // 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.
+    private deployAll(outdatedServices: ServiceConfig[], latestRef: string) {
         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;
             updated.parameters.releaseTime = Date.now();
-            // Always set, never inherited: the overlap belongs to the deploy being made, and leaving the previous deploy's value in place means one no-overlap deploy silently makes every later deploy a no-overlap one. A ternary, as 0 is the value we actually want here and it is falsy.
-            updated.parameters.overlapTime = noOverlap ? 0 : DEFAULT_OVERLAP_TIME;
+            // Always set, never inherited: the overlap belongs to the deploy being made, and leaving the previous deploy's value in place means one no-overlap deploy silently makes every later deploy a no-overlap one.
+            updated.parameters.overlapTime = DEFAULT_OVERLAP_TIME;
             return updated;
         });
         let controller = MachineServiceController(SocketFunction.browserNodeId());
@@ -190,9 +227,13 @@ 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"
+                    title="Asks first, then deploys; the old instances keep running for their configured overlap before shutting down"
                     onClick={() => {
-                        this.deployAll(outdatedServices, gitInfo.latestRef, false);
+                        confirmDeployAll({
+                            titles: outdatedServices.map(service => service.info.title),
+                            latestRef: gitInfo.latestRef,
+                            onConfirm: () => this.deployAll(outdatedServices, gitInfo.latestRef),
+                        });
                     }}
                 >
                     <div>
@@ -207,20 +248,6 @@ export class UpdateButtons extends qreact.Component<{
                         <RenderGitRefInfo gitRef={ref} />
                     </div>)}
                 </button>
-                <button
-                    className={buttonStyle.hsl(0, 85, 70)}
-                    disabled={this.state.isDeploying}
-                    title="Deploys now AND shuts the old instances down as soon as the new ones are up (overlap of 0)"
-                    onClick={() => {
-                        confirmNoOverlapDeploy(`Deploy All (${outdatedServices.length}), No Overlap`, () => {
-                            this.deployAll(outdatedServices, gitInfo.latestRef, true);
-                        });
-                    }}
-                >
-                    <div>
-                        {bigEmoji("⚡")} <span>{this.state.isDeploying && "⏳ Deploying..." || `Deploy All (${outdatedServices.length}), No Overlap`}</span>
-                    </div>
-                </button>
             </>}
         </>;
     }

package/src/deployManager/machineSchema.ts

@@ -415,20 +415,6 @@ export class MachineServiceControllerBase {
         void this.notifyMachines([], getConfigMachineIds(normalizeServiceConfig(serviceConfig)));
     }
 
-    /** 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`);
-        }
-        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)`);
-        }
-        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");
     }
@@ -657,7 +643,6 @@ export const MachineServiceController = getSyncedController(
             setMachineConfig: {},
             addServiceConfig: {},
             setServiceConfigs: {},
-            cancelScheduledDeploy: {},
             getServiceConfigType: {},
             deleteServiceConfig: {},
             getGitInfo: {},
@@ -682,7 +667,6 @@ export const MachineServiceController = getSyncedController(
             setMachineConfig: ["MachineConfig", "MachineConfigList"],
             addServiceConfig: ["ServiceConfig", "ServiceConfigList"],
             setServiceConfigs: ["ServiceConfig"],
-            cancelScheduledDeploy: ["ServiceConfig"],
             deleteServiceConfig: ["ServiceConfig", "ServiceConfigList"],
             commitPushService: ["gitInfo", "ServiceConfig"],
             commitPushAndPublishQuerysub: ["gitInfo", "ServiceConfig"],