querysub 0.518.0 → 0.520.0

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -1,6 +1,6 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { qreact } from "../../4-dom/qreact";
-import { DEFAULT_OVERLAP_TIME, MACHINE_RESYNC_INTERVAL, MachineServiceController, ServiceConfig, ServiceParameters, getLiveServiceParameters, stripReleaseState } from "../machineSchema";
+import { DEFAULT_OVERLAP_TIME, MACHINE_RESYNC_INTERVAL, MachineServiceController, ServiceConfig, ServiceParameters, applyCommandTemplate, getCommandTemplateVariables, getLiveServiceParameters, getMachineTargets, setMachineTargets, stripReleaseState } from "../machineSchema";
 import { css } from "typesafecss";
 import { t } from "../../2-proxy/schema2";
 import { Querysub } from "../../4-querysub/Querysub";
@@ -165,6 +165,47 @@ export class ServiceDetailPage extends qreact.Component {
         });
     }
 
+    // Shows the `${name}` variables found in the command, and lets each picked machine entry set its own values for them (which converts machineIds to the { machineId, variables } form).
+    private renderTemplateVariables(config: ServiceConfig) {
+        let templateVariables = getCommandTemplateVariables(config.parameters.command);
+        let targets = getMachineTargets(config.parameters);
+        let anyVariablesSet = targets.some(target => Object.keys(target.variables).length > 0);
+        if (templateVariables.length === 0 && !anyVariablesSet) return undefined;
+
+        const setVariable = (entryIndex: number, name: string, value: string) => {
+            let updated = deepCloneJSON(config);
+            let updatedTargets = getMachineTargets(updated.parameters);
+            if (value) {
+                updatedTargets[entryIndex].variables[name] = value;
+            } else {
+                delete updatedTargets[entryIndex].variables[name];
+            }
+            setMachineTargets(updated.parameters, updatedTargets);
+            this.updateEditorState(updated);
+        };
+
+        let dupIndexes = new Map<string, number>();
+        return <div className={css.vbox(10).fillWidth.pad2(12).bord2(0, 0, 20)}>
+            {targets.map((target, entryIndex) => {
+                let index = dupIndexes.get(target.machineId) || 0;
+                dupIndexes.set(target.machineId, index + 1);
+                // Variables set on the entry but no longer in the command are still shown (flagged), so stale values can be cleared.
+                let variableNames = [...new Set([...templateVariables, ...Object.keys(target.variables)])];
+                return <div className={css.hbox(12).wrap.alignItems("center").fillWidth}>
+                    <div className={css.boldStyle}>{getScreenName({ serviceKey: config.parameters.key, index })} ({target.machineId})</div>
+                    {variableNames.map(name => {
+                        let inCommand = templateVariables.includes(name);
+                        return <InputLabel
+                            label={inCommand && name || `${name} (not in command)`}
+                            value={target.variables[name] || ""}
+                            onChangeValue={value => setVariable(entryIndex, name, value)}
+                        />;
+                    })}
+                </div>;
+            })}
+        </div>;
+    }
+
     render() {
         const selectedServiceId = selectedServiceIdParam.value;
         if (!selectedServiceId) return <div>No service selected</div>;
@@ -199,8 +240,9 @@ export class ServiceDetailPage extends qreact.Component {
 
         // Sort machines by status and heartbeat
         let nextIndexes = new Map<string, number>();
-        let machineIds = config.parameters.machineIds || [];
-        let machineStatuses = machineIds.map(machineId => {
+        let machineTargets = getMachineTargets(config.parameters);
+        let machineIds = machineTargets.map(x => x.machineId);
+        let machineStatuses = machineTargets.map(({ machineId, variables }) => {
             let index = nextIndexes.get(machineId) || 0;
             nextIndexes.set(machineId, index + 1);
             let machineInfo = controller.getMachineInfo(machineId);
@@ -212,6 +254,7 @@ export class ServiceDetailPage extends qreact.Component {
 
             return {
                 machineId,
+                variables,
                 machineInfo,
                 serviceInfo,
                 isMachineDead,
@@ -297,17 +340,17 @@ export class ServiceDetailPage extends qreact.Component {
                 picked={machineIds}
                 addPicked={machineId => {
                     let updated = deepCloneJSON(config);
-                    updated.parameters.machineIds = [...(updated.parameters.machineIds || []), machineId];
+                    setMachineTargets(updated.parameters, [...getMachineTargets(updated.parameters), { machineId, variables: {} }]);
                     this.updateEditorState(updated);
                 }}
                 removePicked={machineId => {
                     let updated = deepCloneJSON(config);
-                    let updatedMachineIds = updated.parameters.machineIds || [];
-                    let index = updatedMachineIds.indexOf(machineId);
+                    let targets = getMachineTargets(updated.parameters);
+                    let index = targets.findIndex(x => x.machineId === machineId);
                     if (index !== -1) {
-                        updatedMachineIds.splice(index, 1);
+                        targets.splice(index, 1);
                     }
-                    updated.parameters.machineIds = updatedMachineIds;
+                    setMachineTargets(updated.parameters, targets);
                     this.updateEditorState(updated);
                 }}
             />
@@ -325,7 +368,7 @@ export class ServiceDetailPage extends qreact.Component {
             {config.parameters.deploy && <div className={css.vbox(8).fillWidth}>
                 <h3>Deployed Machines ({machineIds.length})</h3>
                 <div className={css.vbox(4).fillWidth}>
-                    {machineStatuses.map(({ machineId, machineInfo, serviceInfo, isMachineDead, hasError, isDisabled, index }) => {
+                    {machineStatuses.map(({ machineId, variables, machineInfo, serviceInfo, isMachineDead, hasError, isDisabled, index }) => {
                         if (!machineInfo) return <div key={machineId}>Loading {machineId}...</div>;
 
                         let backgroundColor = css.hsl(0, 0, 100); // Default: white
@@ -358,6 +401,12 @@ export class ServiceDetailPage extends qreact.Component {
                                     <div>
                                         {serviceInfo?.nodeId || machineId} ({machineInfo.info["getExternalIP"]})
                                     </div>
+                                    {Object.keys(variables).length > 0 && <div
+                                        className={css.fontFamily("monospace").colorhsl(210, 60, 35)}
+                                        title={`Runs: ${applyCommandTemplate(config.parameters.command, variables)}`}
+                                    >
+                                        {Object.entries(variables).map(([name, value]) => `${name}=${value}`).join(" ")}
+                                    </div>}
                                 </div>
                                 {isDisabled && (
                                     <div className={css.colorhsl(0, 0, 30)}>
@@ -708,6 +757,8 @@ export class ServiceDetailPage extends qreact.Component {
                 </div>;
             })()}
 
+            {this.renderTemplateVariables(config)}
+
             {this.state.saveError && (
                 <div className={css.pad2(12).bord2(0, 80, 50).hsl(0, 80, 95).colorhsl(0, 80, 30)}>
                     ⚠️ Error: {this.state.saveError}

package/src/deployManager/components/ServicesListPage.tsx

@@ -1,6 +1,6 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { qreact } from "../../4-dom/qreact";
-import { DEFAULT_OVERLAP_TIME, MachineServiceController, ServiceConfig, getLiveServiceParameters } from "../machineSchema";
+import { DEFAULT_OVERLAP_TIME, MachineServiceController, ServiceConfig, getLiveServiceParameters, getMachineIdList } from "../machineSchema";
 import { css } from "typesafecss";
 import { t } from "../../2-proxy/schema2";
 import { Querysub } from "../../4-querysub/Querysub";
@@ -82,7 +82,7 @@ export class ServicesListPage extends qreact.Component {
                 {services.map(([serviceId, config]) => {
                     if (!config) return <div key={serviceId}>Config is broken? Missing value for service? Is the file corrupted?</div>;
 
-                    let machineIds = config.parameters.machineIds || [];
+                    let machineIds = getMachineIdList(config.parameters);
                     let disabledMachines = machineIds.filter(machineId => {
                         let machineConfig = getMachineConfig(machineId);
                         return machineConfig?.disabled;

package/src/deployManager/components/Tools.tsx

@@ -4,7 +4,7 @@ import { qreact } from "../../4-dom/qreact";
 import { css } from "typesafecss";
 import { t } from "../../2-proxy/schema2";
 import { Querysub } from "../../4-querysub/Querysub";
-import { MachineServiceController, ServiceConfig } from "../machineSchema";
+import { MachineServiceController, ServiceConfig, getMachineTargets, setMachineTargets } from "../machineSchema";
 import { MachinePicker } from "./MachinePicker";
 import { isDefined } from "../../misc";
 
@@ -125,15 +125,11 @@ class RenameMachine extends qreact.Component {
                                 );
                                 let toUpdate: ServiceConfig[] = [];
                                 for (let config of configs.filter(isDefined)) {
-                                    let machineIds = config.parameters.machineIds || [];
-                                    if (!machineIds.includes(from)) continue;
-                                    toUpdate.push({
-                                        ...config,
-                                        parameters: {
-                                            ...config.parameters,
-                                            machineIds: machineIds.map(m => m === from ? to : m),
-                                        },
-                                    });
+                                    let targets = getMachineTargets(config.parameters);
+                                    if (!targets.some(target => target.machineId === from)) continue;
+                                    let updated = { ...config, parameters: { ...config.parameters } };
+                                    setMachineTargets(updated.parameters, targets.map(target => target.machineId === from ? { ...target, machineId: to } : target));
+                                    toUpdate.push(updated);
                                 }
                                 if (toUpdate.length === 0) {
                                     Querysub.commit(() => {

package/src/deployManager/machineApplyMainCode.ts

@@ -4,7 +4,7 @@ import { measureWrap } from "socket-function/src/profiling/measure";
 import { getOwnMachineId } from "sliftutils/misc/https/certs";
 import { forceRemoveNode, getOurNodeId, getOurNodeIdAssert } from "../-f-node-discovery/NodeDiscovery";
 import { Querysub } from "../4-querysub/Querysub";
-import { MACHINE_RESYNC_INTERVAL, MachineServiceControllerBase, MachineInfo, ServiceConfig, ServiceParameters, SERVICE_FOLDER, machineInfos, SERVICE_NODE_FILE_NAME, getEffectiveServiceConfigs, getLiveServiceParameters, restartParametersKey, recordLaunch, DEFAULT_OVERLAP_TIME } from "./machineSchema";
+import { MACHINE_RESYNC_INTERVAL, MachineServiceControllerBase, MachineInfo, ServiceConfig, ServiceParameters, SERVICE_FOLDER, machineInfos, SERVICE_NODE_FILE_NAME, getEffectiveServiceConfigs, getLiveServiceParameters, restartParametersKey, recordLaunch, DEFAULT_OVERLAP_TIME, getMachineTargets, getMachineIdList, applyCommandTemplate } from "./machineSchema";
 import { runPromise } from "../functional/runCommand";
 import { getExternalIP } from "socket-function/src/networking";
 import { errorToUndefined, errorToUndefinedSilent } from "../errors";
@@ -656,7 +656,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
     let machineId = getOwnMachineId(getDomain());
     let allConfigs = await getEffectiveServiceConfigs();
     let relevantConfigs = allConfigs
-        .filter(config => (getLiveServiceParameters(config).machineIds || []).includes(machineId) || (config.parameters.machineIds || []).includes(machineId))
+        .filter(config => getMachineIdList(getLiveServiceParameters(config)).includes(machineId) || getMachineIdList(config.parameters).includes(machineId))
         .filter(x => getLiveServiceParameters(x).deploy || x.parameters.deploy);
 
     let machineInfo = await getLiveMachineInfo();
@@ -676,11 +676,11 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
             console.log(magenta(`Release in flight for ${record.serviceId} (${record.parameters.key}): new instances start at ${new Date(releaseTime - overlapTime).toLocaleString()}${Date.now() >= releaseTime - overlapTime && " (overlap running)" || ""}, old instances shut down at ${new Date(releaseTime).toLocaleString()}`));
             // The release-overlap instances follow the NEW parameters' machineIds, so machines that are only in the new parameters still start their instances at overlap time (their canonical instances start once the release passes)
             if (Date.now() >= releaseTime - overlapTime && record.parameters.deploy) {
-                let nextMatchedCount = (record.parameters.machineIds || []).filter(id => id === machineId).length;
-                for (let i = 0; i < nextMatchedCount; i++) {
+                let nextTargets = getMachineTargets(record.parameters).filter(target => target.machineId === machineId);
+                for (let i = 0; i < nextTargets.length; i++) {
                     try {
                         await ensureNextInstance({
-                            next: record.parameters,
+                            next: { ...record.parameters, command: applyCommandTemplate(record.parameters.command, nextTargets[i].variables) },
                             index: i,
                             screenNamesUsed,
                             screenStateMap,
@@ -692,8 +692,10 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
             }
         }
         if (!config.parameters.deploy) continue;
-        let matchedCount = (config.parameters.machineIds || []).filter(id => id === machineId).length;
-        for (let i = 0; i < matchedCount; i++) {
+        let matchedTargets = getMachineTargets(config.parameters).filter(target => target.machineId === machineId);
+        for (let i = 0; i < matchedTargets.length; i++) {
+            // Each instance runs the command with its own entry's template variables resolved, so the per-instance parameters (written to parameters.json and compared for restarts) carry the resolved command.
+            let instanceParameters = { ...config.parameters, command: applyCommandTemplate(config.parameters.command, matchedTargets[i].variables) };
             let screenName = getScreenName({
                 serviceKey: config.parameters.key,
                 index: i,
@@ -741,9 +743,9 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 if (await fsExistsAsync(parameterPath)) {
                     prevParameters = await fs.promises.readFile(parameterPath, "utf8");
                 }
-                let newParametersString = JSON.stringify(config.parameters);
+                let newParametersString = JSON.stringify(instanceParameters);
 
-                let sameParameters = sameRestartParameters(prevParameters, config.parameters);
+                let sameParameters = sameRestartParameters(prevParameters, instanceParameters);
                 let screenIsRunning = screenStateMap.get(screenName)?.isProcessRunning;
 
                 let nodePathId = folder + SERVICE_NODE_FILE_NAME;
@@ -760,7 +762,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                     continue;
                 }
 
-                console.log(`Resyncing service ${magenta(screenName)}, with ${JSON.stringify(config.parameters)}, isRunning = ${screenIsRunning}, sameParameters = ${sameParameters}`);
+                console.log(`Resyncing service ${magenta(screenName)}, with ${newParametersString}, isRunning = ${screenIsRunning}, sameParameters = ${sameParameters}`);
 
                 await fs.promises.writeFile(parameterPath, newParametersString);
 
@@ -781,7 +783,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
 
                 await runScreenCommand({
                     screenName,
-                    command: config.parameters.command,
+                    command: instanceParameters.command,
                 });
                 await delay(2000);
                 let newScreens = await getScreenState(false);

package/src/deployManager/machineSchema.ts

@@ -66,15 +66,22 @@ export type MachineInfo = {
 };
 
 
+export type MachineTarget = {
+    machineId: string;
+    /** Substituted into the command's `${name}` template placeholders for this machine entry (see applyCommandTemplate). */
+    variables: Record<string, string>;
+};
+
 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[];
+    /** 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 []). Entries are either bare machine ids, or objects carrying per-entry template variables for the command. Use getMachineTargets / setMachineTargets instead of touching this directly. */
+    machineIds?: string[] | MachineTarget[];
 
     repoUrl: string;
     gitRef: string;
+    /** May contain `${name}` template placeholders, filled per machine entry from its variables. Placeholders with no matching variable are left untouched, so bash's own `${ENV}` references keep working. */
     command: string;
     /** Allows forcing an update */
     poke?: number;
@@ -106,6 +113,40 @@ export type ServiceConfig = {
 
 export const DEFAULT_OVERLAP_TIME = timeInMinute * 10;
 
+const TEMPLATE_VARIABLE_REGEX = /\$\{([a-zA-Z0-9_-]+)\}/g;
+/** The `${name}` placeholder names in a command template, in order of first appearance. */
+export function getCommandTemplateVariables(command: string): string[] {
+    let names = new Set<string>();
+    for (let match of command.matchAll(TEMPLATE_VARIABLE_REGEX)) {
+        names.add(match[1]);
+    }
+    return [...names];
+}
+export function applyCommandTemplate(command: string, variables: Record<string, string>): string {
+    return command.replace(TEMPLATE_VARIABLE_REGEX, (placeholder, name) => name in variables ? variables[name] : placeholder);
+}
+
+/** The machineIds entries, normalized to the object form. */
+export function getMachineTargets(parameters: ServiceParameters): MachineTarget[] {
+    return ((parameters.machineIds || []) as (string | MachineTarget)[]).map(entry =>
+        typeof entry === "string"
+            ? { machineId: entry, variables: {} }
+            // Hand-edited configs (ex, via the raw config editor) may omit variables
+            : { machineId: entry.machineId, variables: entry.variables || {} }
+    );
+}
+export function getMachineIdList(parameters: ServiceParameters): string[] {
+    return getMachineTargets(parameters).map(x => x.machineId);
+}
+/** Stores targets back onto parameters, collapsing to the plain string[] form when no entry has variables (keeps configs without templates identical to how they always looked). */
+export function setMachineTargets(parameters: ServiceParameters, targets: MachineTarget[]): void {
+    if (targets.every(target => Object.keys(target.variables).length === 0)) {
+        parameters.machineIds = targets.map(x => x.machineId);
+    } else {
+        parameters.machineIds = targets;
+    }
+}
+
 /** The parameters machines should actually be running right now. */
 export function getLiveServiceParameters(config: ServiceConfig): ServiceParameters {
     let releaseTime = config.parameters.releaseTime;
@@ -121,12 +162,15 @@ export function getLiveServiceConfig(config: ServiceConfig): ServiceConfig {
 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). */
+/** 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). Per-entry template variables DO change what an instance runs, but that is captured by the resolved command in the per-instance parameters the apply code compares (so a variable change restarts only that machine's instance). */
 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 || [])])];
+    return [...new Set([
+        ...getMachineIdList(config.parameters),
+        ...(config.oldParameters ? getMachineIdList(config.oldParameters) : []),
+    ])];
 }
 // Migrates records that stored machineIds at the top level of ServiceConfig (it now lives in parameters)
 function normalizeServiceConfig(config: ServiceConfig): ServiceConfig {
@@ -562,9 +606,9 @@ export async function getEffectiveServiceConfigs(): Promise<ServiceConfig[]> {
 
     return configs.map(config => {
         normalizeServiceConfig(config);
-        config.parameters.machineIds = (config.parameters.machineIds || []).filter(machineId => !disabledMachineIds.has(machineId));
+        setMachineTargets(config.parameters, getMachineTargets(config.parameters).filter(target => !disabledMachineIds.has(target.machineId)));
         if (config.oldParameters) {
-            config.oldParameters.machineIds = (config.oldParameters.machineIds || []).filter(machineId => !disabledMachineIds.has(machineId));
+            setMachineTargets(config.oldParameters, getMachineTargets(config.oldParameters).filter(target => !disabledMachineIds.has(target.machineId)));
         }
         return config;
     });

package/src/diagnostics/managementPages.tsx

@@ -82,9 +82,9 @@ export async function registerManagementPages2(config: {
 
     inputPages.push({
         title: "Routing Table",
-        componentName: "AuthoritySpecPage",
-        controllerName: "AuthoritySpecPageController",
-        getModule: () => import("./misc-pages/AuthoritySpecPage"),
+        componentName: "RoutingTablePage",
+        controllerName: "RoutingTablePageController",
+        getModule: () => import("./misc-pages/RoutingTablePage"),
     });
     inputPages.push({
         title: "LOG VIEWER",