fix: support state save and restore redeploy workflow

examples/state-save-and-restore/scripts/generate-override-network.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs';
+
+class OverrideNetworkGenerator {
+  static main() {
+    const argumentsMap = this.parseArguments(process.argv.slice(2));
+    const sourceNetworkPath = this.requireArgument(argumentsMap, 'source-network');
+    const servicesJsonPath = this.requireArgument(argumentsMap, 'services-json');
+    const nodeAliasesText = this.requireArgument(argumentsMap, 'node-aliases');
+    const outputPath = this.requireArgument(argumentsMap, 'output');
+    const sourceNetwork = JSON.parse(fs.readFileSync(sourceNetworkPath, 'utf8'));
+    const servicesDocument = JSON.parse(fs.readFileSync(servicesJsonPath, 'utf8'));
+    const nodeAliases = nodeAliasesText
+      .split(',')
+      .map(nodeAlias => nodeAlias.trim())
+      .filter(nodeAlias => nodeAlias.length > 0);
+
+    if (!Array.isArray(sourceNetwork.nodeMetadata)) {
+      throw new Error('source network JSON is missing nodeMetadata');
+    }
+
+    if (!Array.isArray(servicesDocument.items)) {
+      throw new Error('services JSON is missing items');
+    }
+
+    if (sourceNetwork.nodeMetadata.length < nodeAliases.length) {
+      throw new Error(
+        `source network only has ${String(sourceNetwork.nodeMetadata.length)} nodeMetadata entries for ${String(nodeAliases.length)} aliases`,
+      );
+    }
+
+    const rewrittenNetwork = structuredClone(sourceNetwork);
+    let changedEndpointCount = 0;
+
+    for (const [nodeIndex, nodeAlias] of nodeAliases.entries()) {
+      const serviceName = `network-${nodeAlias}-svc`;
+      const service = servicesDocument.items.find(candidateService => candidateService?.metadata?.name === serviceName);
+
+      if (!service) {
+        throw new Error(`service not found in services JSON: ${serviceName}`);
+      }
+
+      const clusterIpAddress = service?.spec?.clusterIP;
+      if (typeof clusterIpAddress !== 'string' || clusterIpAddress.length === 0 || clusterIpAddress === 'None') {
+        throw new Error(`service ${serviceName} does not have a usable clusterIP`);
+      }
+
+      const encodedIpAddress = this.encodeIpv4Address(clusterIpAddress);
+      const nodeMetadata = rewrittenNetwork.nodeMetadata[nodeIndex];
+      changedEndpointCount += this.rewriteNodeEndpoints(nodeMetadata, encodedIpAddress, clusterIpAddress, serviceName);
+    }
+
+    if (changedEndpointCount === 0) {
+      throw new Error('override-network.json was not changed; this would not test endpoint remapping');
+    }
+
+    fs.writeFileSync(outputPath, `${JSON.stringify(rewrittenNetwork, null, 2)}\n`);
+    console.log(`Wrote ${outputPath} with ${String(changedEndpointCount)} rewritten endpoint entries`);
+  }
+
+  static parseArguments(argumentList) {
+    const argumentsMap = new Map();
+
+    for (let argumentIndex = 0; argumentIndex < argumentList.length; argumentIndex += 1) {
+      const argument = argumentList[argumentIndex];
+      if (!argument.startsWith('--')) {
+        throw new Error(`Unexpected argument: ${argument}`);
+      }
+
+      const argumentName = argument.slice(2);
+      const argumentValue = argumentList[argumentIndex + 1];
+      if (!argumentValue || argumentValue.startsWith('--')) {
+        throw new Error(`Missing value for --${argumentName}`);
+      }
+
+      argumentsMap.set(argumentName, argumentValue);
+      argumentIndex += 1;
+    }
+
+    return argumentsMap;
+  }
+
+  static requireArgument(argumentsMap, argumentName) {
+    const argumentValue = argumentsMap.get(argumentName);
+    if (!argumentValue) {
+      throw new Error(`Missing required argument --${argumentName}`);
+    }
+    return argumentValue;
+  }
+
+  static encodeIpv4Address(ipAddressText) {
+    const octets = ipAddressText.split('.').map(octetText => Number(octetText));
+
+    if (octets.length !== 4 || octets.some(octet => !Number.isInteger(octet) || octet < 0 || octet > 255)) {
+      throw new Error(`Only IPv4 addresses are supported, got: ${ipAddressText}`);
+    }
+
+    return Buffer.from(octets).toString('base64');
+  }
+
+  static rewriteNodeEndpoints(nodeMetadata, encodedIpAddress, clusterIpAddress, serviceName) {
+    if (!nodeMetadata || typeof nodeMetadata !== 'object') {
+      throw new Error('nodeMetadata entry is missing or invalid');
+    }
+
+    // The restored roster uses gossip endpoints before the service endpoints are
+    // needed. Rewrite both representations so the fresh cluster can establish
+    // peer sync without depending on endpoint names from the source cluster.
+    let changedEndpointCount = this.rewriteEndpointList(
+      nodeMetadata?.node,
+      'gossipEndpoint',
+      encodedIpAddress,
+      clusterIpAddress,
+      serviceName,
+    );
+    changedEndpointCount += this.rewriteEndpointList(
+      nodeMetadata?.node,
+      'serviceEndpoint',
+      encodedIpAddress,
+      clusterIpAddress,
+      serviceName,
+    );
+    changedEndpointCount += this.rewriteEndpointList(
+      nodeMetadata?.rosterEntry,
+      'gossipEndpoint',
+      encodedIpAddress,
+      clusterIpAddress,
+      serviceName,
+    );
+    return changedEndpointCount;
+  }
+
+  static rewriteEndpointList(parentObject, endpointProperty, encodedIpAddress, clusterIpAddress, serviceName) {
+    if (!parentObject || typeof parentObject !== 'object') {
+      throw new Error(`node metadata is missing for ${serviceName}`);
+    }
+
+    const endpoints = parentObject[endpointProperty];
+    if (!Array.isArray(endpoints) || endpoints.length === 0) {
+      throw new Error(`node is missing ${endpointProperty} entries for ${serviceName}`);
+    }
+
+    let changedEndpointCount = 0;
+
+    parentObject[endpointProperty] = endpoints.map(endpoint => {
+      const rewrittenEndpoint = {...endpoint};
+      const existingIpAddress = rewrittenEndpoint.ipAddressV4;
+
+      rewrittenEndpoint.ipAddressV4 = encodedIpAddress;
+      delete rewrittenEndpoint.domainName;
+
+      const endpointChanged = existingIpAddress !== encodedIpAddress;
+      if (endpointChanged) {
+        changedEndpointCount += 1;
+      }
+
+      return rewrittenEndpoint;
+    });
+
+    console.log(`Updated ${endpointProperty} for ${serviceName} -> ${clusterIpAddress}`);
+    return changedEndpointCount;
+  }
+}
+
+try {
+  OverrideNetworkGenerator.main();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exitCode = 1;
+}

resources/cleanup-state-rounds.sh

@@ -35,10 +35,8 @@ for nodeid in */; do
 
     if [ -n "$rounds" ]; then
       latest_round=""
-      pces_source_round=""
       highest_round=$(echo "$rounds" | tail -n 1)
       highest_round_freeze_state=""
-      earliest_signed_non_freeze_round=""
       latest_signed_non_freeze_round=""
       for round in $rounds; do
         metadata_file="${round}/stateMetadata.txt"
@@ -53,9 +51,6 @@ for nodeid in */; do
         fi
 
         if [ "$freeze_state" = "false" ] && [ -n "$signing_weight" ] && [ "$signing_weight" = "$total_weight" ]; then
-          if [ -z "$earliest_signed_non_freeze_round" ]; then
-            earliest_signed_non_freeze_round="$round"
-          fi
           latest_signed_non_freeze_round="$round"
           latest_round="$round"
         fi
@@ -69,83 +64,16 @@ for nodeid in */; do
         latest_round="$highest_round"
       fi
 
-      if [ -z "$pces_source_round" ]; then
-        pces_source_round="$latest_round"
-      fi
-
       round_count=$(echo "$rounds" | wc -l)
 
-      echo "Node ${nodeid}${realmShard}: Found ${round_count} rounds, keeping state: ${latest_round}, PCES: ${pces_source_round}"
+      echo "Node ${nodeid}${realmShard}: Found ${round_count} rounds, keeping state: ${latest_round}"
 
       for round in $rounds; do
-        if [ "$round" != "$latest_round" ] && [ "$round" != "$pces_source_round" ]; then
+        if [ "$round" != "$latest_round" ]; then
           echo "  Removing old round: $round"
           rm -rf "$round"
         fi
       done
-
-      # Rebuild top-level PCES from the selected pre-freeze round so the event
-      # creator has the preconsensus events it needs to become active after
-      # resuming from the kept state.
-      if [ -d "${pces_source_round}/preconsensus-events" ]; then
-        top_level_pces="${HEDERA_HAPI_PATH}/data/saved/preconsensus-events"
-        echo "  Rebuilding top-level preconsensus events from round: $pces_source_round"
-        rm -rf "$top_level_pces"
-        source_pces_dir="${pces_source_round}/preconsensus-events"
-        find "$source_pces_dir" -type f -name '*.pces' | while IFS= read -r pces_file; do
-          relative_pces_path=${pces_file#"$source_pces_dir"/}
-          pces_node_id=${relative_pces_path%%/*}
-          pces_filename=${pces_file##*/}
-          pces_date=${pces_filename%%T*}
-
-          year=$(echo "$pces_date" | cut -d- -f1)
-          month=$(echo "$pces_date" | cut -d- -f2)
-          day=$(echo "$pces_date" | cut -d- -f3)
-
-          if [ -n "$pces_node_id" ] && [ -n "$year" ] && [ -n "$month" ] && [ -n "$day" ] && [ "$pces_date" != "$pces_filename" ]; then
-            pces_destination_dir="${top_level_pces}/${pces_node_id}/${year}/${month}/${day}"
-          else
-            pces_destination_dir="${top_level_pces}/${pces_node_id}"
-          fi
-
-          mkdir -p "$pces_destination_dir"
-          cp "$pces_file" "$pces_destination_dir/"
-        done
-      fi
-
-      if [ -d "${latest_round}/preconsensus-events" ]; then
-        round_pces_dir="${latest_round}/preconsensus-events"
-        round_pces_tmp="${latest_round}/preconsensus-events.tmp"
-        echo "  Normalizing round preconsensus events for state: $latest_round"
-        rm -rf "$round_pces_tmp"
-        mkdir -p "$round_pces_tmp"
-        find "$round_pces_dir" -type f -name '*.pces' | while IFS= read -r pces_file; do
-          relative_pces_path=${pces_file#"$round_pces_dir"/}
-          pces_node_id=${relative_pces_path%%/*}
-          pces_filename=${pces_file##*/}
-          pces_date=${pces_filename%%T*}
-
-          year=$(echo "$pces_date" | cut -d- -f1)
-          month=$(echo "$pces_date" | cut -d- -f2)
-          day=$(echo "$pces_date" | cut -d- -f3)
-
-          if [ -n "$pces_node_id" ] && [ -n "$year" ] && [ -n "$month" ] && [ -n "$day" ] && [ "$pces_date" != "$pces_filename" ]; then
-            pces_destination_dir="${round_pces_tmp}/${pces_node_id}/${year}/${month}/${day}"
-          else
-            pces_destination_dir="${round_pces_tmp}/${pces_node_id}"
-          fi
-
-          mkdir -p "$pces_destination_dir"
-          cp "$pces_file" "$pces_destination_dir/"
-        done
-        rm -rf "$round_pces_dir"
-        mv "$round_pces_tmp" "$round_pces_dir"
-      fi
-
-      if [ "$pces_source_round" != "$latest_round" ] && [ -d "$pces_source_round" ]; then
-        echo "  Removing old round after PCES rebuild: $pces_source_round"
-        rm -rf "$pces_source_round"
-      fi
     fi
 
     cd ../..