From d6548e1d1c7c8901abb3dccc00d17a8571a61d52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1rton=20Boros?= Date: Fri, 9 Oct 2026 23:54:54 +0300 Subject: [PATCH 1/3] test(nix): add pg_upgrade start guard VM test Refs: MPG-1334 Co-Authored-By: Claude Sonnet 5.5 --- nix/ext/tests/pg-upgrade-start-guard.nix | 227 +++++++++++++++++++++++ 1 file changed, 227 insertions(+) create mode 100644 nix/ext/tests/pg-upgrade-start-guard.nix diff --git a/nix/ext/tests/pg-upgrade-start-guard.nix b/nix/ext/tests/pg-upgrade-start-guard.nix new file mode 100644 index 0000000000..c4de5fc6d6 --- /dev/null +++ b/nix/ext/tests/pg-upgrade-start-guard.nix @@ -0,0 +1,227 @@ +{ self, pkgs }: +let + inherit (pkgs) lib; + lpkgs = pkgs.pkgsLinux; + system = lpkgs.stdenv.hostPlatform.system; + + pg15 = self.packages.${system}."psql_15/bin"; + pg17 = self.packages.${system}."psql_17/bin"; + + dataOld = "/var/lib/postgresql/data"; + dataNew = "/var/lib/postgresql/data-17"; + dropIn = "/run/systemd/system/postgresql.service.d/pg-upgrade-lock.conf"; + + initiate = builtins.path { + path = ../../../ansible/files/admin_api_scripts/pg_upgrade_scripts/initiate.sh; + name = "initiate.sh"; + }; + + # initiate.sh runs the upgrade when sourced, so extract only the guard. + startGuard = lpkgs.runCommand "start-guard.sh" { } '' + awk ' + /^PG_UPGRADE_(LOCK|PID|INITIATE|START)_[A-Z_]+=/ { print } + /^(block_postgres_start|start_pid_lock_watcher|unblock_postgres_start|assert_source_stayed_down)\(\) \{/ { printing = 1 } + printing { print } + printing && /^}/ { printing = 0 } + ' ${initiate} >$out + ''; + + guardEnv = lpkgs.writeText "guard-env.sh" '' + export PATH=${ + lib.makeBinPath ( + with lpkgs; + [ + bash + coreutils + diffutils + gnugrep + gnused + procps + systemd + util-linux + ] + ) + } + IS_CI="" + PGDATAOLD=${dataOld} + PGDATANEW=${dataNew} + log() { echo "[$(date +%T)] $*"; } + retry() { + local n=$1 i + shift + for i in $(seq 1 "$n"); do + "$@" && return 0 + sleep 1 + done + return 1 + } + . ${startGuard} + ''; + + holdBlock = lpkgs.writeShellScript "hold-block" '' + set -eEuo pipefail + . ${guardEnv} + systemctl stop postgresql + block_postgres_start + exec sleep infinity + ''; + + saltSim = lpkgs.writeShellScript "salt-sim" '' + export PATH=${ + lib.makeBinPath [ + lpkgs.coreutils + lpkgs.systemd + ] + } + : >/tmp/salt-states + while :; do + systemctl start postgresql 2>/dev/null || true + systemctl is-active postgresql >>/tmp/salt-states || true + sleep 0.1 + done + ''; + + holdLock = lpkgs.writeShellScript "hold-lock" '' + set -eEuo pipefail + . ${guardEnv} + PGDATANEW=/tmp/fake-new + mkdir -p "$PGDATANEW" + runuser -u postgres -- bash -c 'sleep infinity; true' fake-pg-upgrade "--old-datadir=$PGDATAOLD" & + start_pid_lock_watcher + touch "$PGDATANEW/postmaster.pid" + wait + ''; + + guardedUpgrade = lpkgs.writeShellScript "guarded-upgrade" '' + set -eEuo pipefail + . ${guardEnv} + systemctl stop postgresql + block_postgres_start + runuser -u postgres -- ${pg17}/bin/initdb --no-locale -E UTF8 -U postgres -D "$PGDATANEW" + start_pid_lock_watcher + systemd-run --unit=salt-sim --collect ${saltSim} + cd /var/lib/postgresql + runuser -u postgres -- ${pg17}/bin/pg_upgrade \ + --username=postgres \ + --old-datadir="$PGDATAOLD" --new-datadir="$PGDATANEW" \ + --old-bindir=${pg15}/bin --new-bindir=${pg17}/bin + systemctl stop salt-sim + assert_source_stayed_down + unblock_postgres_start + ''; + + initOld = lpkgs.writeShellScript "init-old" '' + set -euo pipefail + if [ ! -f ${dataOld}/PG_VERSION ]; then + ${lpkgs.coreutils}/bin/install -d -o postgres -g postgres -m 0700 ${dataOld} + ${lpkgs.util-linux}/bin/runuser -u postgres -- \ + ${pg15}/bin/initdb --no-locale -E UTF8 -U postgres -D ${dataOld} + fi + ''; +in +pkgs.testers.runNixOSTest { + name = "pg-upgrade-start-guard"; + nodes.server = + { ... }: + { + virtualisation.memorySize = 2048; + virtualisation.diskSize = 4096; + + users.users.postgres = { + isSystemUser = true; + group = "postgres"; + home = "/var/lib/postgresql"; + createHome = true; + }; + users.groups.postgres = { }; + systemd.tmpfiles.rules = [ "d /run/postgresql 0755 postgres postgres -" ]; + + systemd.services.postgresql = { + wantedBy = [ "multi-user.target" ]; + serviceConfig = { + Type = "notify"; + User = "postgres"; + Group = "postgres"; + ExecStartPre = "+${initOld}"; + ExecStart = "${pg15}/bin/postgres -D ${dataOld}"; + KillMode = "mixed"; + KillSignal = "SIGINT"; + Restart = "always"; + RestartSec = 1; + }; + }; + }; + + testScript = '' + PG15 = "${pg15}/bin" + PG17 = "${pg17}/bin" + DROPIN = "${dropIn}" + + def sql(query, port=5432, bindir=PG15): + return server.succeed( + f"{bindir}/psql -h 127.0.0.1 -p {port} -U postgres -d postgres -Atc \"{query}\"" + ).strip() + + start_all() + server.wait_for_unit("postgresql.service") + + with subtest("Seed the source cluster"): + sql("create table seed as select g as id, repeat(md5(g::text), 20) as pad from generate_series(1, 400000) g") + expected = sql("select count(*) || ',' || sum(id) from seed") + + with subtest("Control: with no guard the start loop brings the source up"): + server.succeed("systemctl stop postgresql") + server.succeed("systemd-run --unit=salt-sim --collect ${saltSim}") + server.wait_until_succeeds("systemctl is-active --quiet postgresql", timeout=30) + server.succeed("systemctl stop salt-sim") + + with subtest("A systemd start is refused while the block is held"): + server.succeed("systemd-run --unit=hold-block --collect ${holdBlock}") + server.wait_until_succeeds("systemctl show -p ExecCondition postgresql | grep -q start-guard", timeout=120) + server.fail("systemctl start postgresql") + server.sleep(5) + server.fail("systemctl is-active --quiet postgresql") + assert "Restart=no" in server.succeed("systemctl show -p Restart postgresql") + + with subtest("The block expires on its own when the holder is SIGKILLed"): + server.succeed("systemctl kill -s KILL hold-block") + server.wait_until_fails("systemctl is-active --quiet hold-block") + server.succeed("systemctl start postgresql") + server.wait_for_unit("postgresql.service") + server.fail(f"test -e {DROPIN}") + assert "Restart=always" in server.succeed("systemctl show -p Restart postgresql") + assert "NeedDaemonReload=no" in server.succeed("systemctl show -p NeedDaemonReload postgresql") + + with subtest("The pid lock stops a direct start once the new cluster is up"): + server.succeed("systemctl stop postgresql") + server.succeed("systemd-run --unit=hold-lock --collect ${holdLock}") + server.wait_until_succeeds("test -s ${dataOld}/postmaster.pid", timeout=120) + server.fail(f"runuser -u postgres -- {PG15}/pg_ctl start -D ${dataOld} -w -t 5 -s -l /tmp/pg15-locked.log") + server.succeed("systemctl kill -s KILL hold-lock") + server.wait_until_fails("systemctl is-active --quiet hold-lock") + server.succeed(f"runuser -u postgres -- {PG15}/pg_ctl start -D ${dataOld} -w -s -l /tmp/pg15.log") + server.succeed(f"runuser -u postgres -- {PG15}/pg_ctl stop -D ${dataOld} -w -s") + server.succeed("rm -f /run/pg-upgrade-source.pid") + server.succeed("systemctl start postgresql") + server.wait_for_unit("postgresql.service") + + with subtest("A real pg_upgrade copy under a start storm"): + server.succeed("systemd-run --unit=fake-initiate --collect --pipe --wait ${guardedUpgrade}") + attempts = int(server.succeed("wc -l = 5, f"start loop barely ran: {attempts} attempts" + server.fail("grep -qx active /tmp/salt-states") + + with subtest("The new cluster matches the seed"): + server.succeed( + f"runuser -u postgres -- {PG17}/pg_ctl start -D ${dataNew} -w -s -l /tmp/pg17.log -o '-p 5433'" + ) + assert sql("select count(*) || ',' || sum(id) from seed", port=5433, bindir=PG17) == expected + server.succeed(f"runuser -u postgres -- {PG17}/pg_ctl stop -D ${dataNew} -w -s") + + with subtest("The source is untouched and starts again"): + server.succeed("systemctl start postgresql") + server.wait_for_unit("postgresql.service") + assert sql("select count(*) || ',' || sum(id) from seed") == expected + server.fail(f"test -e {DROPIN}") + ''; +} From 01f168a0a00c68ced6819196be272970724d4599 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1rton=20Boros?= Date: Sat, 10 Oct 2026 00:13:47 +0300 Subject: [PATCH 2/3] test(nix): tidy pg_upgrade start guard VM test Refs: MPG-1334 Co-Authored-By: Claude Sonnet 5.5 --- nix/ext/tests/pg-upgrade-start-guard.nix | 299 +++++++++++------------ 1 file changed, 149 insertions(+), 150 deletions(-) diff --git a/nix/ext/tests/pg-upgrade-start-guard.nix b/nix/ext/tests/pg-upgrade-start-guard.nix index c4de5fc6d6..814a4b181c 100644 --- a/nix/ext/tests/pg-upgrade-start-guard.nix +++ b/nix/ext/tests/pg-upgrade-start-guard.nix @@ -1,15 +1,11 @@ { self, pkgs }: let inherit (pkgs) lib; - lpkgs = pkgs.pkgsLinux; - system = lpkgs.stdenv.hostPlatform.system; - - pg15 = self.packages.${system}."psql_15/bin"; - pg17 = self.packages.${system}."psql_17/bin"; + pg15 = self.packages.${pkgs.pkgsLinux.stdenv.hostPlatform.system}."psql_15/bin"; + pg17 = self.packages.${pkgs.pkgsLinux.stdenv.hostPlatform.system}."psql_17/bin"; dataOld = "/var/lib/postgresql/data"; dataNew = "/var/lib/postgresql/data-17"; - dropIn = "/run/systemd/system/postgresql.service.d/pg-upgrade-lock.conf"; initiate = builtins.path { path = ../../../ansible/files/admin_api_scripts/pg_upgrade_scripts/initiate.sh; @@ -17,7 +13,7 @@ let }; # initiate.sh runs the upgrade when sourced, so extract only the guard. - startGuard = lpkgs.runCommand "start-guard.sh" { } '' + guard = pkgs.pkgsLinux.runCommand "start-guard.sh" { } '' awk ' /^PG_UPGRADE_(LOCK|PID|INITIATE|START)_[A-Z_]+=/ { print } /^(block_postgres_start|start_pid_lock_watcher|unblock_postgres_start|assert_source_stayed_down)\(\) \{/ { printing = 1 } @@ -26,202 +22,205 @@ let ' ${initiate} >$out ''; - guardEnv = lpkgs.writeText "guard-env.sh" '' - export PATH=${ - lib.makeBinPath ( - with lpkgs; - [ - bash - coreutils - diffutils - gnugrep - gnused - procps - systemd - util-linux - ] - ) - } - IS_CI="" - PGDATAOLD=${dataOld} - PGDATANEW=${dataNew} - log() { echo "[$(date +%T)] $*"; } - retry() { - local n=$1 i - shift - for i in $(seq 1 "$n"); do - "$@" && return 0 - sleep 1 - done - return 1 - } - . ${startGuard} - ''; - - holdBlock = lpkgs.writeShellScript "hold-block" '' - set -eEuo pipefail - . ${guardEnv} - systemctl stop postgresql - block_postgres_start - exec sleep infinity - ''; - - saltSim = lpkgs.writeShellScript "salt-sim" '' - export PATH=${ - lib.makeBinPath [ - lpkgs.coreutils - lpkgs.systemd - ] - } - : >/tmp/salt-states - while :; do - systemctl start postgresql 2>/dev/null || true - systemctl is-active postgresql >>/tmp/salt-states || true - sleep 0.1 - done - ''; - - holdLock = lpkgs.writeShellScript "hold-lock" '' - set -eEuo pipefail - . ${guardEnv} - PGDATANEW=/tmp/fake-new - mkdir -p "$PGDATANEW" - runuser -u postgres -- bash -c 'sleep infinity; true' fake-pg-upgrade "--old-datadir=$PGDATAOLD" & - start_pid_lock_watcher - touch "$PGDATANEW/postmaster.pid" - wait - ''; - - guardedUpgrade = lpkgs.writeShellScript "guarded-upgrade" '' - set -eEuo pipefail - . ${guardEnv} - systemctl stop postgresql - block_postgres_start - runuser -u postgres -- ${pg17}/bin/initdb --no-locale -E UTF8 -U postgres -D "$PGDATANEW" - start_pid_lock_watcher - systemd-run --unit=salt-sim --collect ${saltSim} - cd /var/lib/postgresql - runuser -u postgres -- ${pg17}/bin/pg_upgrade \ - --username=postgres \ - --old-datadir="$PGDATAOLD" --new-datadir="$PGDATANEW" \ - --old-bindir=${pg15}/bin --new-bindir=${pg17}/bin - systemctl stop salt-sim - assert_source_stayed_down - unblock_postgres_start - ''; + drive = pkgs.pkgsLinux.writeShellApplication { + name = "drive"; + runtimeInputs = with pkgs.pkgsLinux; [ + bash + coreutils + diffutils + procps + systemd + util-linux + ]; + checkPhase = ""; + text = '' + IS_CI="" + PGDATAOLD=${dataOld} + PGDATANEW=${dataNew} + log() { echo "[$(date +%T)] $*"; } + retry() { + local n=$1 i + shift + for i in $(seq 1 "$n"); do + "$@" && return 0 + sleep 1 + done + return 1 + } + . ${guard} + + hold_block() { + systemctl stop postgresql + block_postgres_start + exec sleep infinity + } + + hold_lock() { + PGDATANEW=/tmp/fake-new + mkdir -p "$PGDATANEW" + runuser -u postgres -- bash -c 'sleep infinity; true' fake-pg-upgrade "--old-datadir=$PGDATAOLD" & + start_pid_lock_watcher + touch "$PGDATANEW/postmaster.pid" + wait + } + + salt_sim() { + : >/tmp/salt-states + while :; do + systemctl start postgresql 2>/dev/null || true + systemctl is-active postgresql >>/tmp/salt-states || true + sleep 0.1 + done + } + + upgrade() { + systemctl stop postgresql + block_postgres_start + runuser -u postgres -- ${pg17}/bin/initdb --no-locale -E UTF8 -U postgres -D "$PGDATANEW" + start_pid_lock_watcher + systemd-run --unit=salt-sim --collect "$0" salt_sim + cd /var/lib/postgresql + runuser -u postgres -- ${pg17}/bin/pg_upgrade \ + --username=postgres \ + --old-datadir="$PGDATAOLD" --new-datadir="$PGDATANEW" \ + --old-bindir=${pg15}/bin --new-bindir=${pg17}/bin + systemctl stop salt-sim + assert_source_stayed_down + unblock_postgres_start + } + + "$@" + ''; + }; - initOld = lpkgs.writeShellScript "init-old" '' - set -euo pipefail - if [ ! -f ${dataOld}/PG_VERSION ]; then - ${lpkgs.coreutils}/bin/install -d -o postgres -g postgres -m 0700 ${dataOld} - ${lpkgs.util-linux}/bin/runuser -u postgres -- \ - ${pg15}/bin/initdb --no-locale -E UTF8 -U postgres -D ${dataOld} - fi - ''; + initOld = pkgs.pkgsLinux.writeShellApplication { + name = "init-old"; + runtimeInputs = with pkgs.pkgsLinux; [ + coreutils + util-linux + ]; + text = '' + if [ ! -f ${dataOld}/PG_VERSION ]; then + install -d -o postgres -g postgres -m 0700 ${dataOld} + runuser -u postgres -- ${pg15}/bin/initdb --no-locale -E UTF8 -U postgres -D ${dataOld} + fi + ''; + }; in pkgs.testers.runNixOSTest { name = "pg-upgrade-start-guard"; - nodes.server = - { ... }: - { - virtualisation.memorySize = 2048; - virtualisation.diskSize = 4096; - users.users.postgres = { + nodes.server = { + virtualisation = { + memorySize = 2048; + diskSize = 4096; + }; + + users = { + users.postgres = { isSystemUser = true; group = "postgres"; home = "/var/lib/postgresql"; createHome = true; }; - users.groups.postgres = { }; - systemd.tmpfiles.rules = [ "d /run/postgresql 0755 postgres postgres -" ]; - - systemd.services.postgresql = { - wantedBy = [ "multi-user.target" ]; - serviceConfig = { - Type = "notify"; - User = "postgres"; - Group = "postgres"; - ExecStartPre = "+${initOld}"; - ExecStart = "${pg15}/bin/postgres -D ${dataOld}"; - KillMode = "mixed"; - KillSignal = "SIGINT"; - Restart = "always"; - RestartSec = 1; - }; + groups.postgres = { }; + }; + + systemd.tmpfiles.rules = [ "d /run/postgresql 0755 postgres postgres -" ]; + + systemd.services.postgresql = { + wantedBy = [ "multi-user.target" ]; + serviceConfig = { + Type = "notify"; + User = "postgres"; + Group = "postgres"; + ExecStartPre = "+${lib.getExe initOld}"; + ExecStart = "${pg15}/bin/postgres -D ${dataOld}"; + KillMode = "mixed"; + KillSignal = "SIGINT"; + Restart = "always"; + RestartSec = 1; }; }; + }; testScript = '' + DRIVE = "${lib.getExe drive}" PG15 = "${pg15}/bin" PG17 = "${pg17}/bin" - DROPIN = "${dropIn}" + OLD = "${dataOld}" + NEW = "${dataNew}" + DROPIN = "/run/systemd/system/postgresql.service.d/pg-upgrade-lock.conf" + + def unit(name, job): + server.succeed(f"systemd-run --unit={name} --collect {DRIVE} {job}") + + def kill(name): + server.succeed(f"systemctl kill -s KILL {name}") + server.wait_until_fails(f"systemctl is-active --quiet {name}") - def sql(query, port=5432, bindir=PG15): + def pg_ctl(bindir, action, data, opts=""): + log = "-l /tmp/pg_ctl.log" if action == "start" else "" + return f"runuser -u postgres -- {bindir}/pg_ctl {action} -D {data} -w -s {log} {opts}" + + def sql(query, bindir=PG15, port=5432): return server.succeed( f"{bindir}/psql -h 127.0.0.1 -p {port} -U postgres -d postgres -Atc \"{query}\"" ).strip() + def show(prop): + return server.succeed(f"systemctl show -p {prop} postgresql") + start_all() server.wait_for_unit("postgresql.service") with subtest("Seed the source cluster"): - sql("create table seed as select g as id, repeat(md5(g::text), 20) as pad from generate_series(1, 400000) g") + sql("create table seed as select g as id, repeat(md5(g::text), 20) as pad from generate_series(1, 100000) g") expected = sql("select count(*) || ',' || sum(id) from seed") with subtest("Control: with no guard the start loop brings the source up"): server.succeed("systemctl stop postgresql") - server.succeed("systemd-run --unit=salt-sim --collect ${saltSim}") - server.wait_until_succeeds("systemctl is-active --quiet postgresql", timeout=30) + unit("salt-sim", "salt_sim") + server.wait_until_succeeds("systemctl is-active --quiet postgresql", timeout=60) server.succeed("systemctl stop salt-sim") with subtest("A systemd start is refused while the block is held"): - server.succeed("systemd-run --unit=hold-block --collect ${holdBlock}") + unit("hold-block", "hold_block") server.wait_until_succeeds("systemctl show -p ExecCondition postgresql | grep -q start-guard", timeout=120) server.fail("systemctl start postgresql") server.sleep(5) server.fail("systemctl is-active --quiet postgresql") - assert "Restart=no" in server.succeed("systemctl show -p Restart postgresql") + assert "Restart=no" in show("Restart") with subtest("The block expires on its own when the holder is SIGKILLed"): - server.succeed("systemctl kill -s KILL hold-block") - server.wait_until_fails("systemctl is-active --quiet hold-block") + kill("hold-block") server.succeed("systemctl start postgresql") server.wait_for_unit("postgresql.service") server.fail(f"test -e {DROPIN}") - assert "Restart=always" in server.succeed("systemctl show -p Restart postgresql") - assert "NeedDaemonReload=no" in server.succeed("systemctl show -p NeedDaemonReload postgresql") + assert "Restart=always" in show("Restart") + assert "NeedDaemonReload=no" in show("NeedDaemonReload") with subtest("The pid lock stops a direct start once the new cluster is up"): server.succeed("systemctl stop postgresql") - server.succeed("systemd-run --unit=hold-lock --collect ${holdLock}") - server.wait_until_succeeds("test -s ${dataOld}/postmaster.pid", timeout=120) - server.fail(f"runuser -u postgres -- {PG15}/pg_ctl start -D ${dataOld} -w -t 5 -s -l /tmp/pg15-locked.log") - server.succeed("systemctl kill -s KILL hold-lock") - server.wait_until_fails("systemctl is-active --quiet hold-lock") - server.succeed(f"runuser -u postgres -- {PG15}/pg_ctl start -D ${dataOld} -w -s -l /tmp/pg15.log") - server.succeed(f"runuser -u postgres -- {PG15}/pg_ctl stop -D ${dataOld} -w -s") + unit("hold-lock", "hold_lock") + server.wait_until_succeeds(f"test -s {OLD}/postmaster.pid", timeout=120) + server.fail(pg_ctl(PG15, "start", OLD, "-t 5")) + kill("hold-lock") + server.succeed(pg_ctl(PG15, "start", OLD)) + server.succeed(pg_ctl(PG15, "stop", OLD)) server.succeed("rm -f /run/pg-upgrade-source.pid") server.succeed("systemctl start postgresql") server.wait_for_unit("postgresql.service") with subtest("A real pg_upgrade copy under a start storm"): - server.succeed("systemd-run --unit=fake-initiate --collect --pipe --wait ${guardedUpgrade}") + server.succeed(f"systemd-run --unit=fake-initiate --collect --pipe --wait {DRIVE} upgrade") attempts = int(server.succeed("wc -l = 5, f"start loop barely ran: {attempts} attempts" server.fail("grep -qx active /tmp/salt-states") with subtest("The new cluster matches the seed"): - server.succeed( - f"runuser -u postgres -- {PG17}/pg_ctl start -D ${dataNew} -w -s -l /tmp/pg17.log -o '-p 5433'" - ) - assert sql("select count(*) || ',' || sum(id) from seed", port=5433, bindir=PG17) == expected - server.succeed(f"runuser -u postgres -- {PG17}/pg_ctl stop -D ${dataNew} -w -s") - - with subtest("The source is untouched and starts again"): - server.succeed("systemctl start postgresql") - server.wait_for_unit("postgresql.service") - assert sql("select count(*) || ',' || sum(id) from seed") == expected - server.fail(f"test -e {DROPIN}") + server.succeed(pg_ctl(PG17, "start", NEW, "-o '-p 5433'")) + assert sql("select count(*) || ',' || sum(id) from seed", PG17, 5433) == expected + server.succeed(pg_ctl(PG17, "stop", NEW)) ''; } From f9df0e17bb4da3b5e79947c3e1b697b22465881c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1rton=20Boros?= Date: Tue, 13 Oct 2026 13:31:53 +0300 Subject: [PATCH 3/3] test(nix): source start_guard.sh in the start guard VM test Refs: MPG-1334 Co-Authored-By: Claude Sonnet 5.5 --- nix/ext/tests/pg-upgrade-start-guard.nix | 25 +++--------------------- 1 file changed, 3 insertions(+), 22 deletions(-) diff --git a/nix/ext/tests/pg-upgrade-start-guard.nix b/nix/ext/tests/pg-upgrade-start-guard.nix index 814a4b181c..e2b9154b8f 100644 --- a/nix/ext/tests/pg-upgrade-start-guard.nix +++ b/nix/ext/tests/pg-upgrade-start-guard.nix @@ -7,21 +7,11 @@ let dataOld = "/var/lib/postgresql/data"; dataNew = "/var/lib/postgresql/data-17"; - initiate = builtins.path { - path = ../../../ansible/files/admin_api_scripts/pg_upgrade_scripts/initiate.sh; - name = "initiate.sh"; + guard = builtins.path { + path = ../../../ansible/files/admin_api_scripts/pg_upgrade_scripts/start_guard.sh; + name = "start_guard.sh"; }; - # initiate.sh runs the upgrade when sourced, so extract only the guard. - guard = pkgs.pkgsLinux.runCommand "start-guard.sh" { } '' - awk ' - /^PG_UPGRADE_(LOCK|PID|INITIATE|START)_[A-Z_]+=/ { print } - /^(block_postgres_start|start_pid_lock_watcher|unblock_postgres_start|assert_source_stayed_down)\(\) \{/ { printing = 1 } - printing { print } - printing && /^}/ { printing = 0 } - ' ${initiate} >$out - ''; - drive = pkgs.pkgsLinux.writeShellApplication { name = "drive"; runtimeInputs = with pkgs.pkgsLinux; [ @@ -38,15 +28,6 @@ let PGDATAOLD=${dataOld} PGDATANEW=${dataNew} log() { echo "[$(date +%T)] $*"; } - retry() { - local n=$1 i - shift - for i in $(seq 1 "$n"); do - "$@" && return 0 - sleep 1 - done - return 1 - } . ${guard} hold_block() {