# Build one installation with 0001-0002 only. That is your "old" binary.
# Build another with all patches applied. That is your "new" binary.


$ export OLD=/path/to/old/bin
$ export NEW=/path/to/new/bin
$ export DEMO=/tmp/ipu-demo
$ export PGHOST=/tmp

# Step 1: initdb the primary with the old (v20) binary

$ mkdir -p $DEMO/archive

$ $OLD/pg_config --version
PostgreSQL 20devel

$ $NEW/pg_config --version
PostgreSQL 21devel

$ $OLD/initdb -D $DEMO/primary

# Step 2: configure the primary and start it on the old version
# WIP: nothing verifies a retention setting, so for the demo,
# wal_keep_size is to keep the primary from removing upgrade
# WAL after it's archived. restore_command should also work.
$ cat >> $DEMO/primary/postgresql.conf <<EOF
port = 5440
cluster_name = 'primary'
archive_mode = on
archive_command = 'cp "%p" "$DEMO/archive/%f"'
wal_keep_size = '1GB'
EOF

$ $OLD/pg_ctl -D $DEMO/primary -l $DEMO/primary.log start
waiting for server to start.... done
server started

$ $OLD/psql -X -p 5440 -d postgres -Atc 'SELECT version()'
PostgreSQL 20devel on x86_64-linux, compiled by gcc-16.2.1, 64-bit

# Step 3: create demo data and an application role on the primary

$ $OLD/psql -X -p 5440 -d postgres <<'EOF'
CREATE ROLE app LOGIN;
CREATE TABLE t (id int PRIMARY KEY, val text);
INSERT INTO t SELECT g, md5(g::text) FROM generate_series(1, 1000) g;
GRANT SELECT, INSERT ON t TO app;
EOF

# Step 4: create the standby from a base backup and start it on the old version

$ $OLD/pg_basebackup -p 5440 -D $DEMO/standby -R -c fast

$ cat >> $DEMO/standby/postgresql.conf <<EOF
port = 6001
cluster_name = 'standby'
restore_command = 'cp "$DEMO/archive/%f" "%p"'
EOF

$ $OLD/pg_ctl -D $DEMO/standby -l $DEMO/standby.log start
waiting for server to start.... done
server started

$ $OLD/psql -X -p 6001 -d postgres -Atc 'SELECT pg_is_in_recovery(), count(*) FROM t'
t|1000

$ $OLD/psql -X -p 5440 -d postgres -Atc 'SELECT application_name, state FROM pg_stat_replication'
standby|streaming

# Step 5: run check on the primary, and look at status on both servers

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW check
pg_inplace_upgrade: the cluster in "/tmp/ipu-demo/primary" can be upgraded

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW status
Data directory:            /tmp/ipu-demo/primary
Role:                      primary
Server:                    running
Owner:                     old version
Cluster state:             in production
Upgrade posture:           not prepared
Latest checkpoint:         0/030000C0 (upgrade flag none)
Upgrade configuration:     absent

$ $NEW/pg_inplace_upgrade -D $DEMO/standby -b $OLD -B $NEW status
Data directory:            /tmp/ipu-demo/standby
Role:                      standby
Server:                    running
Owner:                     old version
Cluster state:             in archive recovery
Upgrade posture:           not prepared
Latest checkpoint:         0/030000C0 (upgrade flag none)
Upgrade configuration:     absent

# Step 6: prepare the primary

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW \
    --standby 'host=/tmp port=6001 dbname=postgres' prepare
pg_inplace_upgrade: refusing client connections
pg_inplace_upgrade: freezing the catalogs
pg_inplace_upgrade: requesting the upgrade boundary
pg_inplace_upgrade: shutting the old version down
pg_inplace_upgrade: the cluster is shut down at the upgrade boundary 0/05000028
pg_inplace_upgrade: standby "host=/tmp port=6001 dbname=postgres" paused at the upgrade boundary

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW status
Data directory:            /tmp/ipu-demo/primary
Role:                      primary
Server:                    stopped
Owner:                     old version
Cluster state:             shut down
Upgrade posture:           at an upgrade boundary
Latest checkpoint:         0/05000028 (upgrade flag boundary)
Upgrade configuration:     present

# standby still up and accepting queries
$ $OLD/psql -X -p 6001 -d postgres -Atc 'SELECT pg_get_wal_replay_pause_state(), pg_upgrade_boundary_lsn()'
paused|0/05000028

# Step 7: swap the primary to the new version

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW -l $DEMO/primary.log swap
pg_inplace_upgrade: starting the new version
pg_inplace_upgrade: the catalogs are migrated, and the cluster serves superusers only until the upgrade goes live

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW status
Data directory:            /tmp/ipu-demo/primary
Role:                      primary
Server:                    running
Owner:                     new version
Cluster state:             in production
Upgrade posture:           migrated
Latest checkpoint:         0/06000028 (upgrade flag start)
Upgrade configuration:     present

$ $NEW/psql -X -p 5440 -d postgres -Atc 'SELECT version(), count(*) FROM t'
PostgreSQL 21devel on x86_64-linux, compiled by gcc-16.2.1, 64-bit|1000

# non-superusers are refused until golive
$ $NEW/psql -X -p 5440 -U app -d postgres -c 'SELECT 1'
psql: error: connection to server on socket "/tmp/.s.PGSQL.5440" failed: FATAL:  pg_hba.conf rejects connection for host "[local]", user "app", database "postgres", no encryption

# standby has seen no effects -- it's still possible to roll back
$ $OLD/psql -X -p 6001 -d postgres -Atc 'SELECT pg_get_wal_replay_pause_state(), count(*) FROM t'
paused|1000

# Step 8: golive on the primary

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW golive
pg_inplace_upgrade: taking the upgrade live
pg_inplace_upgrade: the go-live checkpoint record ends at 0/06D5C538
pg_inplace_upgrade: the upgrade has gone live

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW status
Data directory:            /tmp/ipu-demo/primary
Role:                      primary
Server:                    running
Owner:                     new version
Cluster state:             in production
Upgrade posture:           live
Latest checkpoint:         0/06D5C4A8 (upgrade flag go-live)
Upgrade configuration:     withdrawn

# non-superusers can now connect
$ $NEW/psql -X -p 5440 -U app -d postgres -Atc 'SELECT count(*) FROM t'
1000

$ $NEW/psql -X -p 5440 -d postgres -Atc 'SELECT last_archived_wal, failed_count FROM pg_stat_archiver'
000000010000000000000005|0

$ ls $DEMO/archive
000000010000000000000001  000000010000000000000002.00000028.backup  000000010000000000000004
000000010000000000000002  000000010000000000000003                  000000010000000000000005

$ cat $DEMO/primary/PG_VERSION
21

# Step 9: swap the standby

$ $NEW/pg_inplace_upgrade -D $DEMO/standby -b $OLD -B $NEW -l $DEMO/standby.log swap
pg_inplace_upgrade: stopping the old version
pg_inplace_upgrade: starting the new version
pg_inplace_upgrade: the standby has crossed to the new version

$ $NEW/pg_inplace_upgrade -D $DEMO/standby -b $OLD -B $NEW status
Data directory:            /tmp/ipu-demo/standby
Role:                      standby
Server:                    running
Owner:                     new version
Cluster state:             in archive recovery
Upgrade posture:           live
Latest checkpoint:         0/06000028 (upgrade flag start)
Upgrade configuration:     absent
Consistency hold:          cleared

$ $NEW/psql -X -p 6001 -d postgres -Atc 'SELECT version(), pg_is_in_recovery(), count(*) FROM t'
PostgreSQL 21devel on x86_64-linux, compiled by gcc-16.2.1, 64-bit|t|1000

$ $NEW/psql -X -p 5440 -d postgres -c "INSERT INTO t SELECT g, md5(g::text) FROM generate_series(1001, 1010) g"
INSERT 0 10

$ $NEW/psql -X -p 6001 -d postgres -Atc 'SELECT count(*) FROM t'
1010

$ $NEW/psql -X -p 5440 -d postgres -Atc 'SELECT application_name, state FROM pg_stat_replication'
standby|streaming

# (The first line is from the first start in step 4)
$ grep -E 'took over|went live|consistent recovery' $DEMO/standby.log
LOG:  consistent recovery state reached at 0/02000140
LOG:  took over the standby server for an in-place upgrade
LOG:  in-place upgrade went live at 0/06D5C538
LOG:  consistent recovery state reached at 0/06D5C538

# Still on same timeline
$ $OLD/psql -X -p 6001 -d postgres -Atc 'SELECT received_tli FROM pg_stat_wal_receiver'
1


### Now, if you start over and run up through step 6 or 7, you can also rollback:

# Step R1: roll back the primary (showing rollback after Step 7)

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW -l $DEMO/primary.log rollback
pg_inplace_upgrade: shutting the new version down
pg_inplace_upgrade: restoring the old version''s files XXXXXXXXXXXXXXXXXXXXX
pg_inplace_upgrade: starting the old version
pg_inplace_upgrade: the cluster runs the old version

$ $NEW/pg_inplace_upgrade -D $DEMO/primary -b $OLD -B $NEW status
Data directory:            /tmp/ipu-demo/primary
Role:                      primary
Server:                    running
Owner:                     old version
Cluster state:             in production
Upgrade posture:           not prepared
Latest checkpoint:         0/04000028 (upgrade flag boundary)
Upgrade configuration:     withdrawn

$ cat $DEMO/primary/PG_VERSION
20

$ ls $DEMO/primary | grep inplace
pg_inplace_upgrade.conf.disabled
pg_inplace_upgrade_hba.conf.disabled

# Step R2: roll back the standby

$ $NEW/pg_inplace_upgrade -D $DEMO/standby -b $OLD -B $NEW -l $DEMO/standby.log rollback
pg_inplace_upgrade: resuming replay
pg_inplace_upgrade: the standby resumed replay past the upgrade boundary

$  $NEW/pg_inplace_upgrade -D $DEMO/standby -b $OLD -B $NEW status
Data directory:            /tmp/ipu-demo/standby
Role:                      standby
Server:                    running
Owner:                     old version
Cluster state:             in archive recovery
Upgrade posture:           not prepared
Latest checkpoint:         0/02000088 (upgrade flag none)
Upgrade configuration:     absent

$ cat $DEMO/standby/PG_VERSION
20

# WIP: left behind for forensics
$ ls $DEMO/primary | grep inplace
pg_inplace_upgrade.conf.disabled
pg_inplace_upgrade_hba.conf.disabled

$ $OLD/psql -X -p 5440 -U app -d postgres -c "INSERT INTO t SELECT g, md5(g::text) FROM generate_series(1001, 1010) g"
INSERT 0 10

# Streaming replication is operational...
$ $OLD/psql -X -p 6001 -d postgres -Atc 'SELECT version(), pg_get_wal_replay_pause_state(), count(*) FROM t'
PostgreSQL 20devel on x86_64-linux, compiled by gcc-16.2.1, 64-bit|not paused|1010

# ... on same timeline
$ $OLD/psql -X -p 6001 -d postgres -Atc 'SELECT received_tli FROM pg_stat_wal_receiver'
1

# Teardown

$NEW/pg_ctl -D $DEMO/standby stop
$NEW/pg_ctl -D $DEMO/primary stop
rm -rf $DEMO