querysub 0.511.0 → 0.513.0

package/package.json

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

package/spec.txt

@@ -1,8 +1,3 @@
-todonext
-Make sure the AI updates the machine schema in a smart way. So we can actually have both the old and the new servers config and manage them correctly. make sure if we make multiple updates, it still remembers what the old config is. And make sure deploy all works correctly. 
-
-
-
 Trigger values
     1) validStateComputer.ingestValuesAndValidStates
     1.5) authorityStorage.ingestValues

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -138,12 +138,9 @@ export class ServiceDetailPage extends qreact.Component {
             try {
                 await action();
             } catch (error) {
-                Querysub.localCommit(() => {
+                Querysub.commit(() => {
                     this.state.saveError = error instanceof Error ? error.message : String(error);
                 });
-            } finally {
-                // The write => read invalidation keys should also cover this, but explicitly re-request the config as well, so the UI always reflects what the server now has (only AFTER the action fully finishes, so we can't refetch a value from before our write committed)
-                MachineServiceController(SocketFunction.browserNodeId()).getServiceConfig.refresh(selectedServiceIdParam.value);
             }
         });
     }

package/src/deployManager/components/deployButtons.tsx

@@ -1,11 +1,14 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { qreact } from "../../4-dom/qreact";
+import { t } from "../../2-proxy/schema2";
+import { Querysub } from "../../4-querysub/Querysub";
 import { DEFAULT_OVERLAP_TIME, MachineServiceController, MachineInfo, ServiceConfig } from "../machineSchema";
 import { showFullscreenModal } from "../../5-diagnostics/FullscreenModal";
 import { css } from "../../4-dom/css";
 import { formatTime } from "socket-function/src/formatting/format";
 import { formatDateJSX } from "../../misc/formatJSX";
 import { MachineController } from "../machineController";
+import { deepCloneJSON } from "socket-function/src/misc";
 import { unique } from "../../misc";
 import { CommitModal } from "./CommitModal";
 
@@ -39,6 +42,9 @@ export const buttonStyle = css.pad2(12, 8).button.bord2(0, 0, 20).fontWeight("bo
 export class UpdateButtons extends qreact.Component<{
     services: ServiceConfig[];
 }> {
+    state = t.state({
+        isDeploying: t.type(false),
+    });
     render() {
         let controller = MachineServiceController(SocketFunction.browserNodeId());
         const gitInfo = controller.getGitInfo();
@@ -94,18 +100,31 @@ export class UpdateButtons extends qreact.Component<{
             {outdatedServices.length > 0 && gitInfo &&
                 <button
                     className={buttonStyle.hsl(120, 70, 90)}
-                    onClick={async () => {
-                        for (let service of outdatedServices) {
-                            service.parameters.gitRef = gitInfo.latestRef;
+                    disabled={this.state.isDeploying}
+                    onClick={() => {
+                        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 = gitInfo.latestRef;
                             // Release with the configured overlap, so the new instances are running before the old ones shut down
-                            let overlap = service.parameters.overlapTime || DEFAULT_OVERLAP_TIME;
-                            service.parameters.releaseTime = Date.now() + overlap;
-                        }
-                        await controller.setServiceConfigs.promise(outdatedServices);
+                            let overlap = updated.parameters.overlapTime || DEFAULT_OVERLAP_TIME;
+                            updated.parameters.releaseTime = Date.now() + overlap;
+                            return updated;
+                        });
+                        Querysub.onCommitFinished(async () => {
+                            try {
+                                await controller.setServiceConfigs.promise(toDeploy);
+                            } finally {
+                                Querysub.commit(() => {
+                                    this.state.isDeploying = false;
+                                });
+                            }
+                        });
                     }}
                 >
                     <div>
-                        {bigEmoji("🎯")} <span>Deploy & Restart All ({outdatedServices.length}) Services</span>
+                        {bigEmoji("🎯")} <span>{this.state.isDeploying && "⏳ Deploying..." || `Deploy & Restart All (${outdatedServices.length}) Services`}</span>
                     </div>
                     <div className={css.hbox(5)}>
                         <b>New</b>
@@ -124,6 +143,9 @@ export class UpdateButtons extends qreact.Component<{
 export class UpdateServiceButtons extends qreact.Component<{
     service: ServiceConfig;
 }> {
+    state = t.state({
+        isDeploying: t.type(false),
+    });
     render() {
         let controller = MachineServiceController(SocketFunction.browserNodeId());
         const gitInfo = controller.getGitInfo();
@@ -134,16 +156,28 @@ export class UpdateServiceButtons extends qreact.Component<{
         return <>
             {gitRef !== gitInfo.latestRef && <button
                 className={buttonStyle.hsl(120, 70, 90).alignSelf("stretch")}
-                onClick={async () => {
-                    this.props.service.parameters.gitRef = gitInfo.latestRef;
+                disabled={this.state.isDeploying}
+                onClick={() => {
+                    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 service = deepCloneJSON(this.props.service);
+                    service.parameters.gitRef = gitInfo.latestRef;
                     // Release with the configured overlap, so the new instances are running before the old ones shut down
-                    let overlap = this.props.service.parameters.overlapTime || DEFAULT_OVERLAP_TIME;
-                    this.props.service.parameters.releaseTime = Date.now() + overlap;
-                    await controller.setServiceConfigs.promise([this.props.service]);
+                    let overlap = service.parameters.overlapTime || DEFAULT_OVERLAP_TIME;
+                    service.parameters.releaseTime = Date.now() + overlap;
+                    Querysub.onCommitFinished(async () => {
+                        try {
+                            await controller.setServiceConfigs.promise([service]);
+                        } finally {
+                            Querysub.commit(() => {
+                                this.state.isDeploying = false;
+                            });
+                        }
+                    });
                 }}
             >
                 <div>
-                    {bigEmoji("🎯", -4)} <span>Update to New & Restart</span>
+                    {bigEmoji("🎯", -4)} <span>{this.state.isDeploying && "⏳ Deploying..." || "Update to New & Restart"}</span>
                 </div>
                 <div className={css.hbox(5)}>
                     <b>New</b>

package/src/library-components/SyncedController.ts

@@ -307,7 +307,8 @@ export function getSyncedController<T extends {
                             promise.then(
                                 result => {
                                     logFinished();
-                                    Querysub.commitLocal(() => {
+                                    // commit, NOT commitLocal, as this runs from a promise callback (an async context), where commitLocal writes don't reliably commit / trigger re-renders (which made the write => read invalidation flaky)
+                                    Querysub.commit(() => {
                                         obj.result = atomicObjectWriteNoFreeze({ result });
                                         obj.promise = undefined;
                                         invalidateReaders();
@@ -315,7 +316,7 @@ export function getSyncedController<T extends {
                                 },
                                 error => {
                                     logFinished();
-                                    Querysub.commitLocal(() => {
+                                    Querysub.commit(() => {
                                         obj.result = atomicObjectWriteNoFreeze({ error });
                                         obj.promise = undefined;
                                         invalidateReaders();