diff --git a/.github/workflows/behave-cloudberry.yml b/.github/workflows/behave-cloudberry.yml
new file mode 100644
index 00000000000..e5c0aa55ef2
--- /dev/null
+++ b/.github/workflows/behave-cloudberry.yml
@@ -0,0 +1,924 @@
+#
+# --------------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed
+# with this work for additional information regarding copyright
+# ownership. The ASF licenses this file to You under the Apache
+# License, Version 2.0 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of the
+# License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# --------------------------------------------------------------------
+# GitHub Actions Workflow: Apache Cloudberry Behave Pipeline
+# --------------------------------------------------------------------
+# Description:
+#
+#   This workflow runs Apache Cloudberry gpMgmt Behave tests on Rocky Linux 9.
+#   It is intentionally separated from the main build/installcheck workflow so
+#   that Behave-specific matrix expansion, environment setup, result parsing,
+#   and iterative test stabilization do not disturb the primary CI path.
+#
+# Workflow Overview:
+# 1. **Prepare Behave Matrix**:
+#    - Expands the selected Behave command-level test matrix.
+#    - Supports manual filtering through `test_selection`.
+#
+# 2. **Build Job**:
+#    - Builds Apache Cloudberry and creates source/RPM artifacts for reuse
+#      within this workflow.
+#
+# 3. **Behave Job (Matrix)**:
+#    - Creates a demo cluster for each Behave matrix entry.
+#    - Runs the selected gpMgmt feature file(s) in isolation.
+#    - Parses Behave summaries and uploads logs/metadata artifacts.
+#
+# 4. **Report Job**:
+#    - Aggregates build and Behave job status into a final workflow summary.
+#
+# Execution Environment:
+# - **Runs On**: ubuntu-22.04 with Rocky Linux 9 containers.
+# - **Primary Test Scope**: `gpMgmt/test/behave/mgmt_utils`
+#
+# Notes:
+# - Trigger mode: push, pull_request, and manual `workflow_dispatch`.
+# - Behave tests are split by command to reduce cross-feature environment
+#   pollution.
+# - This workflow currently focuses on single-host CI-compatible Behave tests.
+# - Logs and parsed summaries are uploaded as artifacts for each matrix entry.
+# --------------------------------------------------------------------
+
+name: Apache Cloudberry Behave
+
+on:
+  push:
+    branches: [main, REL_2_STABLE]
+  pull_request:
+    branches: [main, REL_2_STABLE]
+    types: [opened, synchronize, reopened]
+    paths:
+      - 'gpAux/**'
+      - 'gpMgmt/**'
+      - 'src/bin/**'
+      # gp_stat_replication lives here, and gpstate and gprecoverseg steps
+      # query it directly.
+      - 'src/backend/catalog/system_views.sql'
+      - '.github/workflows/behave-cloudberry.yml'
+  workflow_dispatch:
+    inputs:
+      test_selection:
+        description: 'Select Behave tests to run (comma-separated). Examples: ic-behave-gpconfig,ic-behave-gpstart'
+        required: false
+        default: 'all'
+        type: string
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  packages: read
+  actions: write
+  checks: read
+  pull-requests: read
+
+env:
+  LOG_RETENTION_DAYS: 7
+  ENABLE_DEBUG: false
+
+jobs:
+  ## ======================================================================
+  ## Job: check-skip
+  ## Honour the [skip ci] markers documented in the PR template, the same
+  ## way build-cloudberry.yml does. Without this a doc-only PR still pays
+  ## for a full hour of Behave.
+  ## ======================================================================
+  check-skip:
+    runs-on: ubuntu-22.04
+    outputs:
+      should_skip: ${{ steps.skip-check.outputs.should_skip }}
+    steps:
+      - id: skip-check
+        shell: bash
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          PR_TITLE: ${{ github.event.pull_request.title || '' }}
+          PR_BODY: ${{ github.event.pull_request.body || '' }}
+        run: |
+          echo "should_skip=false" >> "$GITHUB_OUTPUT"
+
+          if [[ "$EVENT_NAME" == "pull_request" ]]; then
+            MESSAGE="${PR_TITLE}\n${PR_BODY}"
+            ESCAPED_MESSAGE=$(printf "%s" "$MESSAGE")
+            if echo -e "$ESCAPED_MESSAGE" | grep -qEi '\[skip[ -]ci\]|\[ci[ -]skip\]|\[no[ -]ci\]'; then
+              echo "should_skip=true" >> "$GITHUB_OUTPUT"
+            fi
+          else
+            echo "Skip logic is not applied for $EVENT_NAME events."
+          fi
+
+  prepare-behave-matrix:
+    runs-on: ubuntu-22.04
+    needs: check-skip
+    if: needs.check-skip.outputs.should_skip != 'true'
+    outputs:
+      behave-matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - id: set-matrix
+        # TEST_SELECTION comes in through the environment rather than being
+        # interpolated into the script: a workflow_dispatch input is attacker
+        # controlled, and "${{ ... }}" is substituted before bash parses the
+        # line, so a value like $(...) would run as a command substitution.
+        env:
+          TEST_SELECTION: ${{ github.event.inputs.test_selection || 'all' }}
+        run: |
+          echo "=== Behave Matrix Preparation Diagnostics ==="
+          echo "Event type: ${{ github.event_name }}"
+          echo "Test selection input: '${TEST_SELECTION}'"
+
+          # 17 of the 23 suites under test/behave/mgmt_utils run here. The
+          # other six are left out on purpose:
+          #
+          #   gpcheckperf, gprecoverseg_newhost, gpssh_exkeys
+          #       every scenario in them is @concourse_cluster, so against the
+          #       single-host demo cluster this job builds there is nothing
+          #       left to run once the tag filter has been applied.
+          #   cross_subnet
+          #       needs the coordinator and the segments on separate subnets.
+          #   gpexpand, gppkg
+          #       not enabled yet; both have scenarios that are not
+          #       @concourse_cluster and could be added once they have been
+          #       run against a demo cluster.
+          ALL_BEHAVE_TESTS='{
+            "include": [
+              {"test":"ic-behave-analyzedb","behave_features":["test/behave/mgmt_utils/analyzedb.feature"]},
+              {"test":"ic-behave-gp-bash-functions","behave_features":["test/behave/mgmt_utils/gp_bash_functions.feature"]},
+              {"test":"ic-behave-gpactivatestandby","behave_features":["test/behave/mgmt_utils/gpactivatestandby.feature"]},
+              {"test":"ic-behave-gpaddmirrors",
+               "behave_features":["test/behave/mgmt_utils/gpaddmirrors.feature"],
+               "behave_args":"--tags ~@concourse_cluster"
+              },
+              {"test":"ic-behave-gpcheckcat",
+               "behave_features":["test/behave/mgmt_utils/gpcheckcat.feature"],
+               "behave_args":"--tags ~@extended --tags ~@not_implemented"
+              },
+              {"test":"ic-behave-gpconfig","behave_features":["test/behave/mgmt_utils/gpconfig.feature"]},
+              {"test":"ic-behave-gpinitstandby",
+               "behave_features":["test/behave/mgmt_utils/gpinitstandby.feature"],
+               "behave_args":"--tags ~@concourse_cluster"
+              },
+              {"test":"ic-behave-gpinitsystem",
+               "behave_features":["test/behave/mgmt_utils/gpinitsystem.feature"],
+               "behave_args":"--tags ~@extended"
+              },
+              {"test":"ic-behave-gpmovemirrors",
+               "behave_features":["test/behave/mgmt_utils/gpmovemirrors.feature"],
+               "behave_args":"--tags ~@concourse_cluster --tags ~@extended"
+              },
+              {"test":"ic-behave-gprecoverseg",
+               "behave_features":["test/behave/mgmt_utils/gprecoverseg.feature"],
+               "behave_args":"--tags ~@concourse_cluster --tags ~@extended --tags ~@differential --tags ~@not_implemented"
+              },
+              {"test":"ic-behave-gpreload","behave_features":["test/behave/mgmt_utils/gpreload.feature"]},
+              {"test":"ic-behave-gpstart",
+               "behave_features":["test/behave/mgmt_utils/gpstart.feature"],
+               "behave_args":"--tags ~@concourse_cluster"
+              },
+              {"test":"ic-behave-gpstate",
+               "behave_features":["test/behave/mgmt_utils/gpstate.feature"],
+               "behave_args":"--tags ~@concourse_cluster"
+              },
+              {"test":"ic-behave-gpstop","behave_features":["test/behave/mgmt_utils/gpstop.feature"],
+               "behave_args":"--tags ~@concourse_cluster"
+              },
+              {"test":"ic-behave-gpssh",
+               "behave_features":["test/behave/mgmt_utils/gpssh.feature"],
+               "behave_args":"--tags ~@requires_netem"
+              },
+              {"test":"ic-behave-minirepro",
+               "behave_features":["test/behave/mgmt_utils/minirepro.feature"],
+               "behave_args":"--tags ~@extended"
+              },
+              {"test":"ic-behave-replication-slots",
+               "behave_features":["test/behave/mgmt_utils/replication_slots.feature"],
+               "behave_args":"--tags ~@extended"
+              }
+            ]
+          }'
+
+          VALID_TESTS=$(echo "$ALL_BEHAVE_TESTS" | jq -r '.include[].test')
+          IFS=',' read -ra SELECTED_TESTS <<< "${TEST_SELECTION}"
+
+          if [[ "${SELECTED_TESTS[*]}" == "all" || -z "${SELECTED_TESTS[*]}" ]]; then
+            mapfile -t SELECTED_TESTS <<< "$VALID_TESTS"
+          fi
+
+          INVALID_TESTS=()
+          FILTERED_TESTS=()
+          for TEST in "${SELECTED_TESTS[@]}"; do
+            TEST=$(echo "$TEST" | tr -d '[:space:]')
+            # -F -x -q, not -w: "-" is a word boundary, so grep -w "gpconfig"
+            # matches "ic-behave-gpconfig". Such a name passes validation here
+            # and then matches nothing in the jq select below, leaving an empty
+            # matrix -- the behave job is skipped and the run reports success
+            # without having executed a single scenario.
+            if echo "$VALID_TESTS" | grep -Fxq "$TEST"; then
+              FILTERED_TESTS+=("$TEST")
+            else
+              INVALID_TESTS+=("$TEST")
+            fi
+          done
+
+          if [[ ${#INVALID_TESTS[@]} -gt 0 ]]; then
+            echo "::error::Invalid Behave test(s) selected: ${INVALID_TESTS[*]}"
+            echo "Valid tests are: $(echo "$VALID_TESTS" | tr '\n' ', ')"
+            exit 1
+          fi
+
+          RESULT='{"include":['
+          FIRST=true
+          for TEST in "${FILTERED_TESTS[@]}"; do
+            CONFIG=$(jq -c --arg test "$TEST" '.include[] | select(.test == $test)' <<< "$ALL_BEHAVE_TESTS")
+            if [[ "$FIRST" == true ]]; then
+              FIRST=false
+            else
+              RESULT="${RESULT},"
+            fi
+            RESULT="${RESULT}${CONFIG}"
+          done
+          RESULT="${RESULT}]}"
+
+          echo "Final behave matrix configuration:"
+          echo "$RESULT" | jq .
+
+          {
+            echo "matrix<<EOF"
+            echo "$RESULT"
+            echo "EOF"
+          } >> "$GITHUB_OUTPUT"
+
+  build:
+    name: Build Apache Cloudberry RPM
+    needs: check-skip
+    if: needs.check-skip.outputs.should_skip != 'true'
+    env:
+      JOB_TYPE: build
+    runs-on: ubuntu-22.04
+    timeout-minutes: 120
+    outputs:
+      build_timestamp: ${{ steps.set_timestamp.outputs.timestamp }}
+    container:
+      image: apache/incubator-cloudberry:cbdb-build-rocky9-latest
+      options: >-
+        --user root
+        -h cdw
+        -v /usr/share:/host_usr_share
+        -v /usr/local:/host_usr_local
+        -v /opt:/host_opt
+    steps:
+      - name: Free Disk Space
+        run: |
+          echo "=== Disk space before cleanup ==="
+          df -h /
+
+          rm -rf /host_opt/hostedtoolcache || true
+          rm -rf /host_usr_local/lib/android || true
+          rm -rf /host_usr_share/dotnet || true
+          rm -rf /host_opt/ghc || true
+          rm -rf /host_usr_local/.ghcup || true
+          rm -rf /host_usr_share/swift || true
+          rm -rf /host_usr_local/share/powershell || true
+          rm -rf /host_usr_local/share/chromium || true
+          rm -rf /host_usr_share/miniconda || true
+          rm -rf /host_opt/az || true
+          rm -rf /host_usr_share/sbt || true
+
+          echo "=== Disk space after cleanup ==="
+          df -h /
+
+      - name: Set build timestamp
+        id: set_timestamp
+        run: |
+          timestamp=$(date +'%Y%m%d_%H%M%S')
+          echo "timestamp=$timestamp" | tee -a "$GITHUB_OUTPUT"
+          echo "BUILD_TIMESTAMP=$timestamp" | tee -a "$GITHUB_ENV"
+
+      - name: Checkout Apache Cloudberry
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+          submodules: true
+
+      - name: Cloudberry Environment Initialization
+        env:
+          LOGS_DIR: build-logs
+        run: |
+          set -eo pipefail
+          if ! su - gpadmin -c "/tmp/init_system.sh"; then
+            echo "::error::Container initialization failed"
+            exit 1
+          fi
+
+          mkdir -p "${LOGS_DIR}/details"
+          chown -R gpadmin:gpadmin .
+          chmod -R 755 .
+          chmod 777 "${LOGS_DIR}"
+
+          df -kh /
+          rm -rf /__t/*
+          df -kh /
+
+          df -h | tee -a "${LOGS_DIR}/details/disk-usage.log"
+          free -h | tee -a "${LOGS_DIR}/details/memory-usage.log"
+
+          {
+            echo "=== Environment Information ==="
+            uname -a
+            df -h
+            free -h
+            env
+          } | tee -a "${LOGS_DIR}/details/environment.log"
+
+          echo "SRC_DIR=${GITHUB_WORKSPACE}" | tee -a "$GITHUB_ENV"
+
+      - name: Run Apache Cloudberry configure script
+        env:
+          SRC_DIR: ${{ github.workspace }}
+        run: |
+          set -eo pipefail
+          chmod +x "${SRC_DIR}"/devops/build/automation/cloudberry/scripts/configure-cloudberry.sh
+          if ! time su - gpadmin -c "cd ${SRC_DIR} && SRC_DIR=${SRC_DIR} ENABLE_DEBUG=${{ env.ENABLE_DEBUG }} ${SRC_DIR}/devops/build/automation/cloudberry/scripts/configure-cloudberry.sh"; then
+            echo "::error::Configure script failed"
+            exit 1
+          fi
+
+      - name: Run Apache Cloudberry build script
+        env:
+          SRC_DIR: ${{ github.workspace }}
+        run: |
+          set -eo pipefail
+          chmod +x "${SRC_DIR}"/devops/build/automation/cloudberry/scripts/build-cloudberry.sh
+          if ! time su - gpadmin -c "cd ${SRC_DIR} && SRC_DIR=${SRC_DIR} ${SRC_DIR}/devops/build/automation/cloudberry/scripts/build-cloudberry.sh"; then
+            echo "::error::Build script failed"
+            exit 1
+          fi
+
+      - name: Create Source tarball, create RPM and verify artifacts
+        env:
+          CBDB_VERSION: 99.0.0
+          BUILD_NUMBER: 1
+          SRC_DIR: ${{ github.workspace }}
+        run: |
+          set -eo pipefail
+
+          tar czf "${SRC_DIR}"/../apache-cloudberry-incubating-src.tgz -C "${SRC_DIR}"/.. "./$(basename "${SRC_DIR}")"
+          mv "${SRC_DIR}"/../apache-cloudberry-incubating-src.tgz "${SRC_DIR}"
+
+          # build-rpm.sh creates ~/rpmbuild/{SPECS,SOURCES}, copies the spec
+          # there itself, and stages LICENSE/NOTICE/DISCLAIMER into SOURCES,
+          # which is where the spec's %{_sourcedir} reads them from. Only the
+          # remaining rpmbuild directories need creating up front.
+          rpmdev-setuptree
+
+          DEBUG_RPMBUILD_OPT=""
+          DEBUG_IDENTIFIER=""
+          if [ "${{ env.ENABLE_DEBUG }}" = "true" ]; then
+             DEBUG_RPMBUILD_OPT="--with-debug"
+             DEBUG_IDENTIFIER=".debug"
+          fi
+
+          "${SRC_DIR}"/devops/build/packaging/rpm/build-rpm.sh --version "${CBDB_VERSION}" --release "${BUILD_NUMBER}" "${DEBUG_RPMBUILD_OPT}"
+
+          os_version=$(grep -oP '(?<=^VERSION_ID=")[0-9]' /etc/os-release)
+          RPM_FILE="${HOME}"/rpmbuild/RPMS/x86_64/apache-cloudberry-db-incubating-"${CBDB_VERSION}"-"${BUILD_NUMBER}""${DEBUG_IDENTIFIER}".el"${os_version}".x86_64.rpm
+          cp "${RPM_FILE}" "${SRC_DIR}"
+          RPM_DEBUG="${HOME}"/rpmbuild/RPMS/x86_64/apache-cloudberry-db-incubating-debuginfo-"${CBDB_VERSION}"-"${BUILD_NUMBER}""${DEBUG_IDENTIFIER}".el"${os_version}".x86_64.rpm
+          cp "${RPM_DEBUG}" "${SRC_DIR}"
+
+      - name: Upload build logs
+        uses: actions/upload-artifact@v4
+        with:
+          name: behave-build-logs-${{ env.BUILD_TIMESTAMP }}
+          path: |
+            build-logs/
+          retention-days: ${{ env.LOG_RETENTION_DAYS }}
+
+      - name: Upload Cloudberry RPM build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: apache-cloudberry-db-incubating-rpm-build-artifacts
+          retention-days: ${{ env.LOG_RETENTION_DAYS }}
+          if-no-files-found: error
+          path: |
+            *.rpm
+
+      - name: Upload Cloudberry source build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: apache-cloudberry-db-incubating-source-build-artifacts
+          retention-days: ${{ env.LOG_RETENTION_DAYS }}
+          if-no-files-found: error
+          path: |
+            apache-cloudberry-incubating-src.tgz
+
+  behave:
+    name: ${{ matrix.test }}
+    needs: [check-skip, build, prepare-behave-matrix]
+    if: |
+      !cancelled() &&
+      needs.check-skip.outputs.should_skip != 'true' &&
+      needs.prepare-behave-matrix.result == 'success' &&
+      needs.build.result == 'success'
+    runs-on: ubuntu-22.04
+    timeout-minutes: 120
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.prepare-behave-matrix.outputs.behave-matrix) }}
+    container:
+      image: apache/incubator-cloudberry:cbdb-build-rocky9-latest
+      options: >-
+        --privileged
+        --user root
+        --hostname cdw
+        --shm-size=2gb
+        --ulimit core=-1
+        --cgroupns=host
+        -v /sys/fs/cgroup:/sys/fs/cgroup:rw
+        -v /usr/share:/host_usr_share
+        -v /usr/local:/host_usr_local
+        -v /opt:/host_opt
+    steps:
+      - name: Free Disk Space
+        run: |
+          echo "=== Disk space before cleanup ==="
+          df -h /
+
+          rm -rf /host_opt/hostedtoolcache || true
+          rm -rf /host_usr_local/lib/android || true
+          rm -rf /host_usr_share/dotnet || true
+          rm -rf /host_opt/ghc || true
+          rm -rf /host_usr_local/.ghcup || true
+          rm -rf /host_usr_share/swift || true
+          rm -rf /host_usr_local/share/powershell || true
+          rm -rf /host_usr_local/share/chromium || true
+          rm -rf /host_usr_share/miniconda || true
+          rm -rf /host_opt/az || true
+          rm -rf /host_usr_share/sbt || true
+
+          echo "=== Disk space after cleanup ==="
+          df -h /
+
+      - name: Cloudberry Environment Initialization
+        env:
+          LOGS_DIR: build-logs
+        run: |
+          set -eo pipefail
+          if ! su - gpadmin -c "/tmp/init_system.sh"; then
+            echo "::error::Container initialization failed"
+            exit 1
+          fi
+
+          mkdir -p "${LOGS_DIR}/details"
+          chown -R gpadmin:gpadmin .
+          chmod -R 755 .
+          chmod 777 "${LOGS_DIR}"
+
+          df -kh /
+          rm -rf /__t/*
+          df -kh /
+
+          df -h | tee -a "${LOGS_DIR}/details/disk-usage.log"
+          free -h | tee -a "${LOGS_DIR}/details/memory-usage.log"
+
+          {
+            echo "=== Environment Information ==="
+            uname -a
+            df -h
+            free -h
+            env
+          } | tee -a "${LOGS_DIR}/details/environment.log"
+
+          echo "SRC_DIR=${GITHUB_WORKSPACE}" | tee -a "$GITHUB_ENV"
+
+          # Ensure hostname resolves to IPv4, not ::1, so that gpinitsystem
+          # generates pg_hba.conf entries that gpstop/gpstart can use.
+          # Note: Do NOT remove ::1 cdw mapping. The demo cluster may be
+          # configured with IPv6 loopback addresses, and removing ::1 would
+          # cause SSH-based pg_ctl operations to fail.
+          echo '127.0.0.1 cdw' >> /etc/hosts
+
+          # Pre-populate SSH known_hosts for the demo cluster hostname
+          # to avoid host-key prompts during SSH-based gp commands.
+          mkdir -p /home/gpadmin/.ssh
+          ssh-keyscan $(hostname) >> /home/gpadmin/.ssh/known_hosts 2>/dev/null
+          chown -R gpadmin:gpadmin /home/gpadmin/.ssh
+
+      - name: Generate Behave Job Summary Start
+        if: always()
+        run: |
+          {
+            echo "# Behave Job Summary: ${{ matrix.test }}"
+            echo "## Environment"
+            echo "- Start Time: $(date -u +'%Y-%m-%d %H:%M:%S UTC')"
+            echo "- OS Version: $(cat /etc/redhat-release)"
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Download Cloudberry RPM build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: apache-cloudberry-db-incubating-rpm-build-artifacts
+          path: ${{ github.workspace }}/rpm_build_artifacts
+          merge-multiple: false
+          run-id: ${{ github.run_id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download Cloudberry Source build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: apache-cloudberry-db-incubating-source-build-artifacts
+          path: ${{ github.workspace }}/source_build_artifacts
+          merge-multiple: false
+          run-id: ${{ github.run_id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Verify downloaded artifacts
+        id: verify-artifacts
+        run: |
+          set -eo pipefail
+
+          SRC_TARBALL_FILE=$(ls "${GITHUB_WORKSPACE}"/source_build_artifacts/apache-cloudberry-incubating-src.tgz)
+          if [ ! -f "${SRC_TARBALL_FILE}" ]; then
+            echo "::error::SRC TARBALL file not found"
+            exit 1
+          fi
+          echo "src_tarball_file=${SRC_TARBALL_FILE}" >> "$GITHUB_OUTPUT"
+
+          RPM_FILE=$(ls "${GITHUB_WORKSPACE}"/rpm_build_artifacts/apache-cloudberry-db-incubating-[0-9]*.rpm | grep -v "debuginfo")
+          if [ ! -f "${RPM_FILE}" ]; then
+            echo "::error::RPM file not found"
+            exit 1
+          fi
+          echo "rpm_file=${RPM_FILE}" >> "$GITHUB_OUTPUT"
+
+      - name: Install Cloudberry RPM
+        if: success()
+        env:
+          RPM_FILE: ${{ steps.verify-artifacts.outputs.rpm_file }}
+        run: |
+          set -eo pipefail
+
+          dnf clean all
+          dnf makecache --refresh || dnf makecache
+          rm -rf /usr/local/cloudberry-db
+
+          if ! time dnf install -y --setopt=retries=10 --releasever=9 "${RPM_FILE}"; then
+            echo "::error::RPM installation failed"
+            exit 1
+          fi
+
+          # The RPM installs as root; Behave runs as gpadmin, and some
+          # scenarios change permissions under $GPHOME (for example
+          # gpinitstandby.feature's "$GPHOME/share directory is non-writable").
+          # -H follows the command-line symlink.
+          chown -RH gpadmin:gpadmin /usr/local/cloudberry-db/
+
+          rm -rf "${GITHUB_WORKSPACE}"/rpm_build_artifacts
+
+      - name: Extract source tarball
+        if: success()
+        env:
+          SRC_TARBALL_FILE: ${{ steps.verify-artifacts.outputs.src_tarball_file }}
+          SRC_DIR: ${{ github.workspace }}
+        run: |
+          set -eo pipefail
+
+          if ! time tar zxf "${SRC_TARBALL_FILE}" -C "${SRC_DIR}"/.. ; then
+            echo "::error::Source extraction failed"
+            exit 1
+          fi
+
+          rm -rf "${GITHUB_WORKSPACE}"/source_build_artifacts
+
+      - name: Create Apache Cloudberry demo cluster
+        if: success()
+        env:
+          SRC_DIR: ${{ github.workspace }}
+        run: |
+          set -eo pipefail
+          chmod +x "${SRC_DIR}"/devops/build/automation/cloudberry/scripts/create-cloudberry-demo-cluster.sh
+
+          if ! time su - gpadmin -c "cd ${SRC_DIR} && NUM_PRIMARY_MIRROR_PAIRS='3' SRC_DIR=${SRC_DIR} ${SRC_DIR}/devops/build/automation/cloudberry/scripts/create-cloudberry-demo-cluster.sh"; then
+            echo "::error::Demo cluster creation failed"
+            exit 1
+          fi
+
+      - name: Run Behave Tests
+        if: success()
+        env:
+          SRC_DIR: ${{ github.workspace }}
+        shell: bash {0}
+        run: |
+          set -o pipefail
+
+          mkdir -p build-logs/details
+          config_log="build-logs/details/make-${{ matrix.test }}-config0.log"
+          behave_targets="${{ join(matrix.behave_features, ' ') }}"
+          behave_args="${{ matrix.behave_args || '' }}"
+
+          mkdir -p "/tmp/cloudberry-cores"
+          chmod 1777 "/tmp/cloudberry-cores"
+          sysctl -w kernel.core_pattern="/tmp/cloudberry-cores/core-%e-%s-%u-%g-%p-%t"
+
+          dnf install -y libffi-devel || echo "Warning: failed to install libffi-devel"
+          su - gpadmin -c "pip3 install --user -r ${SRC_DIR}/gpMgmt/requirements-dev.txt || pip install --user -r ${SRC_DIR}/gpMgmt/requirements-dev.txt"
+
+          echo "Running features:"
+          for feature in $behave_targets; do
+            echo "- $feature"
+          done
+          if [[ -n "$behave_args" ]]; then
+            echo "Behave args: $behave_args"
+          fi
+
+          behave_rc=0
+          if ! time su - gpadmin -c "cd ${SRC_DIR}/gpMgmt && source /usr/local/cloudberry-db/cloudberry-env.sh && source ${SRC_DIR}/gpAux/gpdemo/gpdemo-env.sh && SRC_DIR=${SRC_DIR} PYTHONPATH=${SRC_DIR}/gpMgmt:\$PYTHONPATH behave $behave_args $behave_targets" \
+               2>&1 | tee -a "$config_log"; then
+            echo "::warning::Behave execution reported failures"
+            behave_rc=1
+          fi
+
+          # A Behave run can segfault a backend without failing a scenario, so
+          # analyse whatever landed in the cores directory before giving up on
+          # this job. Mirrors the build workflow's handling.
+          echo "-----------------------------------------"
+          echo "Contents of cores directory:"
+          ls -Rl "/tmp/cloudberry-cores" || true
+          echo "-----------------------------------------"
+          "${SRC_DIR}"/devops/build/automation/cloudberry/scripts/analyze_core_dumps.sh "${{ matrix.test }}"
+          case "$?" in
+            0) echo "No core dumps found for this configuration" ;;
+            1) echo "Core dumps were found and analyzed successfully" ;;
+            2) echo "::warning::Issues encountered during core dump analysis" ;;
+            *) echo "::error::Unexpected return code from core dump analysis" ;;
+          esac
+
+          exit $behave_rc
+
+      - name: Check for Core Dumps
+        if: always()
+        env:
+          SRC_DIR: ${{ github.workspace }}
+        shell: bash {0}
+        run: |
+          # The analysis script writes a log whether or not it found anything,
+          # so only look at the ones that actually analysed a core.
+          analysed=$(grep -l "Analyzing core file:" \
+                       "${SRC_DIR}"/build-logs/core_analysis_*.log 2>/dev/null)
+
+          if [ -z "$analysed" ]; then
+            echo "No core dumps were found during test execution"
+            exit 0
+          fi
+
+          # Several scenarios make a segment's data directory unreadable and
+          # then start it, so the startup process reaches
+          #   PANIC: could not open file "pg_wal/...": Permission denied
+          # ereport(PANIC) calls abort(), which leaves a core behind. Those are
+          # the test doing its job, not a crash -- report them, but only fail
+          # the job on a core that is not an ereport(PANIC): a segmentation
+          # fault, a bus error, or a failed Assert (ExceptionalCondition).
+          # gpstop escalates SIGTERM -> SIGQUIT -> SIGABRT when a postmaster
+          # will not shut down, and "gpstop succeeds when pg_ctl command fails"
+          # exercises exactly that by injecting a 3600 second sleep into
+          # checkpoint. The abort is the behaviour under test, so the core it
+          # leaves belongs to a scenario that passed. Only treat a SIGABRT core
+          # as expected when gpstop said in this job's own log that it sent the
+          # signal; without that line a SIGABRT core is still a failure.
+          gpstop_sent_sigabrt=no
+          if grep -rqs "Sending SIGABRT signal" \
+               "${SRC_DIR}"/build-logs/details/ 2>/dev/null; then
+            gpstop_sent_sigabrt=yes
+          fi
+
+          status=0
+          for file in $analysed; do
+            echo "Core analysis file: $file"
+            echo "=== Content ==="
+            cat "$file"
+            echo "=============="
+
+            if grep -q "ExceptionalCondition" "$file"; then
+              echo "::error::${file}: assertion failure"
+              status=1
+            elif grep -qE "Program terminated with signal (SIGSEGV|SIGBUS|SIGILL|SIGFPE)" "$file"; then
+              echo "::error::${file}: crash signal"
+              status=1
+            elif grep -q "errfinish" "$file"; then
+              echo "::warning::${file}: ereport(PANIC) core, expected for scenarios that break a segment on purpose"
+            elif [ "$gpstop_sent_sigabrt" = yes ] &&
+                 grep -q "Program terminated with signal SIGABRT" "$file"; then
+              echo "::warning::${file}: SIGABRT core from gpstop's shutdown escalation, expected for the pg_ctl-failure scenario"
+            else
+              echo "::error::${file}: unrecognised core, treating as a failure"
+              status=1
+            fi
+          done
+
+          exit $status
+
+      - name: Parse Behave Results
+        if: always()
+        shell: bash {0}
+        run: |
+          set -o pipefail
+
+          config_log="build-logs/details/make-${{ matrix.test }}-config0.log"
+          behave_cmd="behave ${{ matrix.behave_args || '' }} ${{ join(matrix.behave_features, ' ') }}"
+          if [ ! -f "$config_log" ]; then
+            {
+              echo "MAKE_COMMAND=\"${behave_cmd}\""
+              echo "STATUS=missing_log"
+              echo "TOTAL_TESTS=0"
+              echo "FAILED_TESTS=0"
+              echo "PASSED_TESTS=0"
+              echo "IGNORED_TESTS=0"
+            } | tee "test_results.${{ matrix.test }}.0.txt"
+            exit 1
+          fi
+
+          features_line=$(grep -E '^[0-9]+ feature(s)? passed, [0-9]+ failed, [0-9]+ skipped$' "$config_log" | tail -n 1)
+          scenarios_line=$(grep -E '^[0-9]+ scenario(s)? passed, [0-9]+ failed, [0-9]+ skipped(, [0-9]+ untested)?$' "$config_log" | tail -n 1)
+          steps_line=$(grep -E '^[0-9]+ step(s)? passed, [0-9]+ failed, [0-9]+ skipped, [0-9]+ undefined(, [0-9]+ untested)?$' "$config_log" | tail -n 1)
+
+          if [[ -z "$scenarios_line" ]]; then
+            {
+              echo "MAKE_COMMAND=\"${behave_cmd}\""
+              echo "STATUS=parse_error"
+              echo "TOTAL_TESTS=0"
+              echo "FAILED_TESTS=0"
+              echo "PASSED_TESTS=0"
+              echo "IGNORED_TESTS=0"
+            } | tee "test_results.${{ matrix.test }}.0.txt"
+            exit 1
+          fi
+
+          scenario_counts=$(echo "$scenarios_line" | sed -E 's/^([0-9]+) scenario(s)? passed, ([0-9]+) failed, ([0-9]+) skipped(, ([0-9]+) untested)?$/\1 \3 \4 \6/')
+          read -r scenarios_passed scenarios_failed scenarios_skipped scenarios_untested <<< "$scenario_counts"
+          scenarios_untested=${scenarios_untested:-0}
+          total_scenarios=$((scenarios_passed + scenarios_failed + scenarios_skipped))
+
+          {
+            echo "MAKE_COMMAND=\"${behave_cmd}\""
+            if [[ "$scenarios_failed" -eq 0 ]]; then
+              echo "STATUS=passed"
+            else
+              echo "STATUS=failed"
+            fi
+            echo "TOTAL_TESTS=${total_scenarios}"
+            echo "FAILED_TESTS=${scenarios_failed}"
+            echo "PASSED_TESTS=${scenarios_passed}"
+            echo "IGNORED_TESTS=${scenarios_skipped}"
+            echo "BEHAVE_UNTESTED_SCENARIOS=${scenarios_untested}"
+            echo "BEHAVE_FEATURES_SUMMARY=\"${features_line:-unavailable}\""
+            echo "BEHAVE_SCENARIOS_SUMMARY=\"${scenarios_line}\""
+            echo "BEHAVE_STEPS_SUMMARY=\"${steps_line:-unavailable}\""
+          } | tee "test_results.${{ matrix.test }}.0.txt"
+
+          if [[ "$scenarios_failed" -eq 0 ]]; then
+            exit 0
+          fi
+          exit 1
+
+      - name: Generate Behave Job Summary End
+        if: always()
+        shell: bash {0}
+        run: |
+          {
+            echo "## Test Results"
+            echo "- End Time: $(date -u +'%Y-%m-%d %H:%M:%S UTC')"
+
+            if [[ ! -f "test_results.${{ matrix.test }}.0.txt" ]]; then
+              echo "### Result Status"
+              echo "⚠️ No results file found"
+              exit 0
+            fi
+
+            . "test_results.${{ matrix.test }}.0.txt"
+
+            echo "### Command"
+            echo "\`$MAKE_COMMAND\`"
+            echo ""
+
+            echo "### Status"
+            case "${STATUS:-unknown}" in
+              passed)
+                echo "✅ All scenarios passed"
+                ;;
+              failed)
+                echo "❌ Some scenarios failed"
+                ;;
+              parse_error)
+                echo "⚠️ Could not parse Behave results"
+                ;;
+              missing_log)
+                echo "⚠️ Behave log file missing"
+                ;;
+              *)
+                echo "⚠️ Unknown status: ${STATUS:-unknown}"
+                ;;
+            esac
+
+            echo ""
+            echo "### Scenario Counts"
+            echo "| Metric | Count |"
+            echo "|--------|-------|"
+            echo "| Total Scenarios | ${TOTAL_TESTS:-0} |"
+            echo "| Passed Scenarios | ${PASSED_TESTS:-0} |"
+            echo "| Failed Scenarios | ${FAILED_TESTS:-0} |"
+            echo "| Skipped Scenarios | ${IGNORED_TESTS:-0} |"
+            echo "| Untested Scenarios | ${BEHAVE_UNTESTED_SCENARIOS:-0} |"
+
+            echo ""
+            echo "### Behave Summary"
+            echo "| Metric | Summary |"
+            echo "|--------|---------|"
+            echo "| Features | ${BEHAVE_FEATURES_SUMMARY:-unavailable} |"
+            echo "| Scenarios | ${BEHAVE_SCENARIOS_SUMMARY:-unavailable} |"
+            echo "| Steps | ${BEHAVE_STEPS_SUMMARY:-unavailable} |"
+          } >> "$GITHUB_STEP_SUMMARY" || true
+
+      - name: Collect gpAdminLogs
+        if: always()
+        shell: bash {0}
+        run: |
+          # gpsegsetuprecovery/gpsegrecovery and the management utilities log
+          # here, not to stdout, so without this a failed recovery leaves no
+          # evidence in the artifacts. Collect them as a tarball: some of the
+          # names contain a colon (gpgetstatususingtransition.py_cdw:gpadmin_*.log)
+          # and upload-artifact rejects those outright, failing the whole upload.
+          if [ -d /home/gpadmin/gpAdminLogs ]; then
+            tar czf build-logs/gpAdminLogs.tar.gz -C /home/gpadmin gpAdminLogs 2>/dev/null || true
+            ls -l build-logs/gpAdminLogs.tar.gz 2>/dev/null || echo "no gpAdminLogs collected"
+          else
+            echo "no gpAdminLogs directory"
+          fi
+
+      - name: Upload behave logs
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: behave-logs-${{ matrix.test }}-${{ needs.build.outputs.build_timestamp || github.run_id }}
+          path: |
+            build-logs/
+          retention-days: ${{ env.LOG_RETENTION_DAYS }}
+
+      - name: Upload Behave Metadata
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: behave-metadata-${{ matrix.test }}
+          path: |
+            test_results*.txt
+          retention-days: ${{ env.LOG_RETENTION_DAYS }}
+
+  report:
+    name: Generate Apache Cloudberry Behave Report
+    needs: [check-skip, build, prepare-behave-matrix, behave]
+    if: always() && needs.check-skip.outputs.should_skip != 'true'
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Generate Final Report
+        run: |
+          {
+            echo "# Apache Cloudberry Behave Report"
+            echo "## Job Status"
+            echo "- Build Job: ${{ needs.build.result }}"
+            echo "- Behave Job: ${{ needs.behave.result }}"
+            echo "- Completion Time: $(date -u +'%Y-%m-%d %H:%M:%S UTC')"
+
+            if [[ "${{ needs.build.result }}" == "success" &&
+                  "${{ needs.behave.result }}" =~ ^(success|skipped)$ ]]; then
+              echo "✅ Pipeline completed successfully"
+            else
+              echo "⚠️ Pipeline completed with failures"
+            fi
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Notify on failure
+        if: |
+          needs.build.result != 'success' ||
+          !contains(fromJson('["success","skipped"]'), needs.behave.result)
+        run: |
+          echo "::error::Behave pipeline failed! Check job summaries and logs for details"
+          echo "Timestamp: $(date -u +'%Y-%m-%d %H:%M:%S UTC')"
+          echo "Build Result: ${{ needs.build.result }}"
+          echo "Behave Result: ${{ needs.behave.result }}"
diff --git a/gpAux/gpdemo/demo_cluster.sh b/gpAux/gpdemo/demo_cluster.sh
index 225bb76a5ee..42973227b36 100755
--- a/gpAux/gpdemo/demo_cluster.sh
+++ b/gpAux/gpdemo/demo_cluster.sh
@@ -314,8 +314,13 @@ cat >> $CLUSTER_CONFIG <<-EOF
 	
 	COORDINATOR_PORT=${COORDINATOR_DEMO_PORT}
 	
-	# Shell to use to execute commands on all hosts
-	TRUSTED_SHELL="$(dirname "$0")/lalshell"
+	# Shell to use to execute commands on all hosts. gpinitsystem sources this
+	# file from whatever directory it runs in, so the path has to be absolute;
+	# \$(dirname \$0) on its own is relative whenever this script was invoked by
+	# a relative path. Resolve the directory holding lalshell -- the one this
+	# script lives in -- and quote it so a path containing whitespace survives
+	# being sourced.
+	TRUSTED_SHELL="$(cd "$(dirname "$0")" && pwd)/lalshell"
 	
 	ENCODING=UNICODE
 EOF
diff --git a/gpMgmt/bin/analyzedb b/gpMgmt/bin/analyzedb
index ff7ced099f1..a0637d54a0a 100755
--- a/gpMgmt/bin/analyzedb
+++ b/gpMgmt/bin/analyzedb
@@ -167,12 +167,24 @@ SELECT schemaname, tablename FROM
 ORDER BY tableoid DESC;
 """
 
+def quote_literal(value):
+    """
+    Quote a name for use inside a SQL string literal.
+
+    Not pg.escape_string(): PyGreSQL's C implementation encodes its argument as
+    ASCII and raises UnicodeEncodeError on a schema, table or column name that
+    contains non-ASCII characters. With standard_conforming_strings on -- the
+    default -- doubling single quotes is the whole of the escaping needed.
+    """
+    return value.replace("'", "''")
+
+
 def validate_schema_exists(pg_port, dbname, schema):
     conn = None
     try:
         dburl = dbconn.DbURL(port=pg_port, dbname=dbname)
         conn = dbconn.connect(dburl)
-        count = dbconn.querySingleton(conn, "select count(*) from pg_namespace where nspname='%s';" % pg.escape_string(schema))
+        count = dbconn.querySingleton(conn, "select count(*) from pg_namespace where nspname='%s';" % quote_literal(schema))
         if count == 0:
             raise ExceptionNoStackTraceNeeded("Schema %s does not exist in database %s." % (schema, dbname))
     finally:
@@ -982,7 +994,7 @@ def get_oid_str(table_list):
 def regclass_schema_tbl(schema, tbl):
     schema_tbl = "%s.%s" % (escape_identifier(schema), escape_identifier(tbl))
 
-    return "to_regclass('%s')" % (pg.escape_string(schema_tbl))
+    return "to_regclass('%s')" % quote_literal(schema_tbl)
 
 
 # Escape double-quotes in a string, so that the resulting string is suitable for
@@ -1250,7 +1262,7 @@ def validate_tables(conn, tablenames):
     while curr_batch < nbatches:
         batch = tablenames[curr_batch * batch_size:(curr_batch + 1) * batch_size]
 
-        oid_str = ','.join(map((lambda x: "('%s')" % pg.escape_string(x)), batch))
+        oid_str = ','.join(map((lambda x: "('%s')" % quote_literal(x)), batch))
         if not oid_str:
             break
 
@@ -1266,7 +1278,7 @@ def get_include_cols_from_exclude(conn, schema, table, exclude_cols):
     """
     Given a list of excluded columns of a table, get the list of included columns
     """
-    quoted_exclude_cols = ','.join(["'%s'" % pg.escape_string(x) for x in exclude_cols])
+    quoted_exclude_cols = ','.join(["'%s'" % quote_literal(x) for x in exclude_cols])
 
     oid_str = regclass_schema_tbl(schema, table)
     cols = run_sql(conn, GET_INCLUDED_COLUMNS_FROM_EXCLUDE_SQL % (oid_str, quoted_exclude_cols))
@@ -1282,7 +1294,7 @@ def validate_columns(conn, schema, table, column_list):
         return
 
     sql = VALIDATE_COLUMN_NAMES_SQL % (regclass_schema_tbl(schema, table),
-                                       ','.join(["'%s'" % pg.escape_string(x) for x in column_list]))
+                                       ','.join(["'%s'" % quote_literal(x) for x in column_list]))
     valid_col_count = dbconn.querySingleton(conn, sql)
 
     if int(valid_col_count) != len(column_list):
diff --git a/gpMgmt/bin/gpcheckcat b/gpMgmt/bin/gpcheckcat
index 00c2e4b21f3..5c0036d96a0 100755
--- a/gpMgmt/bin/gpcheckcat
+++ b/gpMgmt/bin/gpcheckcat
@@ -1075,9 +1075,12 @@ def checkOwners():
                     a.rolname, m.rolname as coordinator_rolname
     from gp_dist_random('pg_class') r
       join pg_class c on (c.oid = r.oid)
+      left join pg_index i on (c.oid = i.indexrelid)
       left join pg_appendonly ao on (c.oid = ao.segrelid or
                                      c.oid = ao.blkdirrelid or
-                                     c.oid = ao.blkdiridxid)
+                                     c.oid = ao.visimaprelid or
+                                     i.indrelid = ao.blkdirrelid or
+                                     i.indrelid = ao.visimaprelid)
       left join pg_class o on (o.oid = ao.relid or
                                o.reltoastrelid = c.oid)
       join pg_authid a on (a.oid = r.relowner)
@@ -1948,6 +1951,207 @@ def checkOrphanedToastTables():
                                issue_type="orphaned_toast_tables",
                                description='Repairing orphaned TOAST tables')
 
+# The mix_distribution_policy check below -- fetch_guc_value(),
+# generateDistPolicyQueryFile(), checkMixDistPolicy() and their helpers --
+# is cherry-picked from Greenplum Database (greenplum-db/gpdb-archive @ 482967c1b4),
+# gpMgmt/bin/gpcheckcat.
+def fetch_guc_value(guc):
+    qry = '''
+    show {}
+     '''.format(guc)
+    try:
+        conn = connect2(GV.cfg[GV.coordinator_dbid])
+        curs = conn.query(qry)
+        rows = curs.getresult()
+        guc_value = rows[0][0]
+        return guc_value
+
+    except Exception as e:
+        setError(ERROR_NOREPAIR)
+        GV.checkStatus = False
+        myprint('[ERROR] executing test: mix_distribution_policy')
+        myprint('  Execution error: ' + str(e))
+
+def generateDistPolicyQueryFile():
+
+    query_sql = '''
+     -- all tables that use legacy policy:
+     with legacy_opclass_oids(oid_array) as (
+       select
+         array_agg(oid)
+       from
+         pg_opclass
+       where
+         opcfamily in (
+           select
+             amprocfamily
+           from
+             pg_amproc
+           where
+             amproc :: oid in (
+               6140, 6141, 6142, 6143, 6144, 6145, 6146,
+               6147, 6148, 6149, 6150, 6151, 6152,
+               6153, 6154, 6155, 6156, 6157, 6158,
+               6159, 6160, 6161, 6162, 6163, 6164,
+               6165, 6166, 6167, 6168, 6170, 6169,
+               6171
+             )
+         )
+     )
+    select
+         localoid :: regclass :: text as "Legacy Policy"
+    from
+         gp_distribution_policy,
+         legacy_opclass_oids
+     where
+         policytype = 'p'
+         and distclass :: oid[] && oid_array;
+  
+ -- all tables that don't use any legacy policy:
+ with legacy_opclass_oids(oid_array) as (
+   select
+     array_agg(oid)
+   from
+     pg_opclass
+   where
+     opcfamily in (
+       select
+         amprocfamily
+       from
+         pg_amproc
+       where
+         amproc :: oid in (
+           6140, 6141, 6142, 6143, 6144, 6145, 6146,
+           6147, 6148, 6149, 6150, 6151, 6152,
+           6153, 6154, 6155, 6156, 6157, 6158,
+           6159, 6160, 6161, 6162, 6163, 6164,
+           6165, 6166, 6167, 6168, 6170, 6169,
+           6171
+         )
+     )
+ )
+select
+   localoid :: regclass :: text as "Non Legacy Policy"
+from
+   gp_distribution_policy,
+   legacy_opclass_oids
+where
+   policytype = 'p'
+   and not (distclass :: oid[] && oid_array);
+           '''
+    filename = 'gpcheckcat.distpolicy.sql'
+
+    if not os.path.exists(filename) :
+        try:
+            with open(filename, 'w') as fp:
+                fp.write(query_sql + "\n")
+        except Exception as e:
+            logger.warning('Unable to generate verify file for {}'.format(filename))
+
+
+# Test to check if there are tables that use both legacy opclass/non legacy opclass
+# in distribution policy
+def checkMixDistPolicy() :
+ 
+    qry = '''
+        with legacy_opclass_oids(oid_array) as (
+        select
+          array_agg(oid)
+        from
+          pg_opclass
+        where
+          opcfamily in (
+            select
+              amprocfamily
+            from
+              pg_amproc
+            where
+              amproc :: oid in (
+                6140, 6141, 6142, 6143, 6144, 6145, 6146,
+                6147, 6148, 6149, 6150, 6151, 6152,
+                6153, 6154, 6155, 6156, 6157, 6158,
+                6159, 6160, 6161, 6162, 6163, 6164,
+                6165, 6166, 6167, 6168, 6170, 6169,
+                6171
+            )
+        )
+       ),
+       all_hash_ops(dc) as (
+        select
+          distinct unnest(distclass :: oid[]) 
+        from
+          gp_distribution_policy
+        )
+        select
+            count(1) filter(
+        where
+            array[x.dc] && oid_array
+            ) as n_legacy_dist_class,
+            count(1) as n_total_dist_class
+        from
+        all_hash_ops x,
+        legacy_opclass_oids y;
+    '''
+
+    try:
+        conn = connect2(GV.cfg[GV.coordinator_dbid])
+        curs = conn.query(qry)
+        rows = curs.getresult()
+
+        if rows:
+            row = rows[0]
+            n_legacy_dist_class = row[0]
+            n_total_dist_class = row[1]
+            GV.checkStatus = False
+
+            if n_legacy_dist_class > 0 and n_total_dist_class > n_legacy_dist_class :
+                generateDistPolicyQueryFile()
+                #if this condition is true then we have mix distribution Policy
+                myprint(
+                    '[ERROR]: Found tables created using both legacy and non legacy hashops'
+                    ' in distribution policy.'
+                    'Please run the gpcheckcat.distpolicy.sql file to list the tables.'
+                )
+            else:
+                if (n_legacy_dist_class == 0 or n_legacy_dist_class == n_total_dist_class):
+                #if this condition is true then we dont have mix distribution policy
+                    gp_use_legacy_hashops = fetch_guc_value("gp_use_legacy_hashops")
+                    printDistPolicyMsg(gp_use_legacy_hashops,
+                                     n_legacy_dist_class,
+                                     n_total_dist_class
+                                     )
+
+    except Exception as e:
+        setError(ERROR_NOREPAIR)
+        GV.checkStatus = False
+        myprint('[ERROR] executing test: mix_distribution_policy')
+        myprint('  Execution error: ' + str(e))
+
+def printDistPolicyMsg(gp_use_legacy_hashops,n_legacy_dist_class, n_total_dist_class):
+
+    GV.checkStatus = True
+
+    if n_total_dist_class - n_legacy_dist_class > 0  and gp_use_legacy_hashops == "on":
+        myprint(
+            '[ERROR]: GUC gp_use_legacy_hashops is on.'
+            ' all newly created tables will use legacy hash ops by default for hash distributed table, '
+            'but there are tables using non-legacy hash ops in the cluster. '
+            'Please run the gpcheckcat.distpolicy.sql file to list the tables.'
+            )
+        GV.checkStatus = False
+
+    elif n_legacy_dist_class == 0 and gp_use_legacy_hashops == "off":
+        GV.checkStatus = True
+
+    elif n_legacy_dist_class > 0 and gp_use_legacy_hashops == "off" :
+        myprint(
+            '[ERROR]: GUC gp_use_legacy_hashops is off.'
+            ' all newly created tables will use non legacy hash ops by default for hash distributed table, '
+            'but there are tables using legacy hash ops in the cluster. '
+            'Please run the gpcheckcat.distpolicy.sql file to list the tables.'
+            )
+        GV.checkStatus = False
+
 
 ############################################################################
 # Help populating repair part for all checked types
@@ -2082,7 +2286,16 @@ all_checks = {
             "version": 'main',
             "order": 15,
             "online": False
+        },
+     "mix_distribution_policy":
+        {
+            "description": "Check for tables that use legacy opclass in distribution policy",
+            "fn": lambda: checkMixDistPolicy(),
+            "version": 'main',
+            "order": 17,
+            "online": True
         }
+
 }
 
 
@@ -2366,6 +2579,7 @@ TableMainColumn['pg_type_encoding'] = ['typid', 'pg_type']
 TableMainColumn['pg_window'] = ['winfnoid', 'pg_proc']
 TableMainColumn['pg_password_history'] = ['passhistroleid', 'pg_authid']
 TableMainColumn['pg_description'] = ['objoid', 'pg_description']
+TableMainColumn['pg_shdescription'] = ['objoid', 'pg_shdescription']
 
 # Table with OID (special case), these OIDs are known to be inconsistent
 TableMainColumn['pg_attrdef'] = ['adrelid', 'pg_class']
diff --git a/gpMgmt/bin/gpinitsystem b/gpMgmt/bin/gpinitsystem
index fa85d42ae3f..cfbcb43e6c6 100755
--- a/gpMgmt/bin/gpinitsystem
+++ b/gpMgmt/bin/gpinitsystem
@@ -313,7 +313,7 @@ CHK_PARAMS () {
 		fi
 
 		if [ x"$ETCD_HOST_CONFIG" = x"" ] || [ x"$CLUSTER_BOOT_MODE" = x"DEMO" ]; then
-			LOG_MSG "[WARN]:-No ETCD cluster host config provided, use default configuration."
+			LOG_MSG "[INFO]:-No ETCD cluster host config provided, use default configuration."
 		else
 			ETCD_HOST_MACHINE_LIST=(`$CAT $ETCD_HOST_CONFIG`)
 			ETCD_HOST_CONFIG_NUM=${#ETCD_HOST_MACHINE_LIST[@]}
@@ -323,7 +323,7 @@ CHK_PARAMS () {
 		fi
 
 		if [ x"$FTS_HOST_CONFIG" = x"" ] || [ x"$CLUSTER_BOOT_MODE" = x"DEMO" ]; then
-			LOG_MSG "[WARN]:-No FTS cluster host config provided, use default configuration."
+			LOG_MSG "[INFO]:-No FTS cluster host config provided, use default configuration."
 		else
 			FTS_HOST_MACHINE_LIST=(`$CAT $FTS_HOST_CONFIG`)
 			FTS_HOST_CONFIG_NUM=${#FTS_HOST_MACHINE_LIST[@]}
@@ -1531,11 +1531,18 @@ CREATE_STANDBY_QD () {
 		if [ $HBA_HOSTNAMES -eq 1 ]; then
 		    INIT_STANDBY_ARGS+=" --hba-hostnames"
 		fi
-		if [ x"$CLUSTER_BOOT_MODE" = x"PRODUCTION" ]; then
-		    export COORDINATOR_DATA_DIRECTORY=${COORDINATOR_DIRECTORY}/${SEG_PREFIX}-1;$INIT_STANDBY_PROG -s $STANDBY_HOSTNAME $INIT_STANDBY_ARGS -a -f $FTS_HOST_STRING_LIST
-		else
-		    export COORDINATOR_DATA_DIRECTORY=${COORDINATOR_DIRECTORY}/${SEG_PREFIX}-1;$INIT_STANDBY_PROG -s $STANDBY_HOSTNAME $INIT_STANDBY_ARGS -a
-		fi
+		# -f takes the list of external FTS hosts, and only exists when the
+		# cluster was given one. Guard it the same way as the arguments above:
+		# CLUSTER_BOOT_MODE is PRODUCTION for every cluster whose coordinator
+		# and segments are on different hosts -- which is every real one --
+		# but FTS_HOST_STRING_LIST is empty unless -f/-F was passed to
+		# gpinitsystem, and "-f" with nothing after it makes gpinitstandby
+		# exit 2 on "-f option requires 1 argument" before it writes a line of
+		# its own log.
+		if [ x"" != x"$FTS_HOST_STRING_LIST" ]; then
+		    INIT_STANDBY_ARGS+=" -f $FTS_HOST_STRING_LIST"
+		fi
+		export COORDINATOR_DATA_DIRECTORY=${COORDINATOR_DIRECTORY}/${SEG_PREFIX}-1;$INIT_STANDBY_PROG -s $STANDBY_HOSTNAME $INIT_STANDBY_ARGS -a
 		STANDBY_RET_CODE=$?
 		if [ $STANDBY_RET_CODE -eq 0 ]; then
 			LOG_MSG "[INFO]:-Successfully completed standby coordinator initialization" 1
@@ -1641,6 +1648,12 @@ FORCE_FTS_PROBE () {
         if [ x"$RESULT" == x"f" ]; then
         	break
         fi
+
+        # Ask FTS to probe now rather than waiting out gp_fts_probe_interval;
+        # without this the loop just re-reads an unchanged
+        # gp_segment_configuration sixty times in a couple of seconds and gives
+        # up before FTS has looked at the segments even once.
+        $PSQL -p $GP_PORT -d "$DEFAULTDB" -c "select gp_request_fts_probe_scan()" >> ${LOG_FILE} 2>&1
     done
     LOG_MSG "[INFO]:-End Function $FUNCNAME"
 }
@@ -1994,7 +2007,7 @@ CBDB_PRECHECK() {
                 if [ $? -eq 0 ];then
                         ERROR_EXIT "[FATAL]: FTS HOST $fts has alived fts process, please cleanup the environment first."
                 fi
-                if [ -z FTS_HOST_STRING_LIST ];then
+                if [ -z "$FTS_HOST_STRING_LIST" ];then
                          FTS_HOST_STRING_LIST="$fts"
                 else
                          FTS_HOST_STRING_LIST="$FTS_HOST_STRING_LIST,$fts"
diff --git a/gpMgmt/bin/gppylib/commands/gp.py b/gpMgmt/bin/gppylib/commands/gp.py
index b980bc629c4..0a2944b48a0 100644
--- a/gpMgmt/bin/gppylib/commands/gp.py
+++ b/gpMgmt/bin/gppylib/commands/gp.py
@@ -53,6 +53,11 @@
 #max batch size of thread pool on coordinator
 MAX_COORDINATOR_NUM_WORKERS=64
 
+# Maximum replay lag (in GBs) allowed on mirror when rebalancing the segments
+# The default value for ALLOWED_REPLAY_LAG has been decided to be 10 GBs as mirror
+# took 5 mins to replay 10 GB lag on a local demo cluster.
+ALLOWED_REPLAY_LAG = 10
+
 # Application name used by the pg_rewind instance that gprecoverseg starts
 # during incremental recovery. gpstate uses this to figure out when incremental
 # recovery is active.
@@ -1034,12 +1039,12 @@ class GpSegRecovery(Command):
     """
     Format gpsegrecovery call for running pg_basebackup/pg_rewind on remoteHost for the segments passed in confinfo
     """
-    def __init__(self, name, confinfo, logdir, batchSize, verbose, remoteHost, forceoverwrite, era):
-        cmdStr = _get_cmd_for_recovery_wrapper('gpsegrecovery', confinfo, logdir, batchSize, verbose, forceoverwrite, era)
+    def __init__(self, name, confinfo, logdir, batchSize, verbose, remoteHost, forceoverwrite, era, maxRate):
+        cmdStr = _get_cmd_for_recovery_wrapper('gpsegrecovery', confinfo, logdir, batchSize, verbose, forceoverwrite, era, maxRate)
         Command.__init__(self, name, cmdStr, REMOTE, remoteHost, start_new_session=True)
 
 
-def _get_cmd_for_recovery_wrapper(wrapper_filename, confinfo, logdir, batchSize, verbose, forceoverwrite, era=None):
+def _get_cmd_for_recovery_wrapper(wrapper_filename, confinfo, logdir, batchSize, verbose, forceoverwrite, era=None, maxRate=None):
     cmdStr = '$GPHOME/sbin/{}.py -c {} -l {}'.format(wrapper_filename, shlex.quote(confinfo), shlex.quote(logdir))
 
     if verbose:
@@ -1050,6 +1055,8 @@ def _get_cmd_for_recovery_wrapper(wrapper_filename, confinfo, logdir, batchSize,
         cmdStr += " --force-overwrite"
     if era:
         cmdStr += " --era={}".format(era)
+    if maxRate:
+        cmdStr += " --max-rate {}".format(maxRate)
 
     return cmdStr
 
@@ -1670,6 +1677,18 @@ def createTempDirectoryName(coordinatorDataDirectory, tempDirPrefix):
                                 datetime.datetime.now().strftime('%m%d%Y'),
                                 os.getpid())
 
+# Cherry-picked from Greenplum Database (greenplum-db/gpdb-archive @ 482967c1b4),
+# gpMgmt/bin/gppylib/commands/gp.py.
+def is_gprecoverseg_running():
+    gprecoverseg_pidfile = os.path.join(get_coordinatordatadir(), 'gprecoverseg.lock', 'PID')
+    try:
+        with open(gprecoverseg_pidfile) as pidfile:
+            gprecoverseg_pid = pidfile.read()
+    except Exception:
+        return False
+
+    return check_pid(gprecoverseg_pid)
+
 #-------------------------------------------------------------------------
 class GpRecoverSeg(Command):
    """
diff --git a/gpMgmt/bin/gppylib/commands/pg.py b/gpMgmt/bin/gppylib/commands/pg.py
index 676f240e037..50dc1312dae 100644
--- a/gpMgmt/bin/gppylib/commands/pg.py
+++ b/gpMgmt/bin/gppylib/commands/pg.py
@@ -8,6 +8,9 @@
 
 from gppylib.gplog import *
 from gppylib.gparray import *
+from gppylib.db import dbconn
+from contextlib import closing
+from pgdb import DatabaseError
 from .base import *
 from .unix import *
 from gppylib.commands.base import *
@@ -205,10 +208,67 @@ def __init__(self, name, target_datadir, source_host, source_port, progress_file
 
         Command.__init__(self, name, self.cmdStr, LOCAL)
 
+# cherry-pick from Greenplum Database
+# greenplum-db/gpdb-archive @ 482967c1b4, gpMgmt/bin/gppylib/commands/pg.py
+class PgReplicationSlot:
+    """
+    PgReplicationSlot have utility function related to replication slot
+    """
+    def __init__(self, host, port, slot_name):
+        """
+        @param host
+        @param port
+        @param slot_name
+        """
+        self.host = host
+        self.port = port
+        self.name = slot_name
+
+    def slot_exists(self):
+        count = -1
+        logger.debug('Checking if slot {} exists for host:{}, port:{}'.format(self.name, self.host, self.port))
+        sql = "SELECT count(*) FROM pg_catalog.pg_replication_slots WHERE slot_name = '{}'". format(self.name)
+        try:
+            dburl = dbconn.DbURL(hostname=self.host, port=self.port)
+            with closing(dbconn.connect(dburl, utility=True, encoding='UTF8')) as conn:
+                count = dbconn.querySingleton(conn, sql)
+        except Exception as ex:
+            raise Exception("Failed to query pg_replication_slots for host:{}, port:{}: {}".
+                            format(self.host, self.port, str(ex)))
+
+        if count == 0:
+            logger.debug("Slot {} does not exist for host:{}, port:{}".
+                         format(self.name, self.host, self.port))
+            return False
+
+        return True
+
+    def drop_slot(self):
+        logger.debug("Dropping slot {} for host:{}, port:{}".format(self.name, self.host, self.port))
+        sql = "SELECT pg_drop_replication_slot('{}');".format(self.name)
+        try:
+            dburl = dbconn.DbURL(hostname=self.host, port=self.port)
+            with closing(dbconn.connect(dburl, utility=True, encoding='UTF8')) as conn:
+                dbconn.query(conn, sql)
+        except DatabaseError as e:
+            # one of the case can be where slot is present but currently in active state
+            logger.exception("Failed to query pg_drop_replication_slot for host:{}, port:{}: {}".
+                             format(self.host, self.port, str(e)))
+            return False
+        except Exception as ex:
+            raise Exception("Failed to drop replication slot for host:{}, port:{} : {}".
+                            format(self.host, self.port, str(ex)))
+
+        logger.debug("Successfully dropped replication slot {} for host:{}, port:{}".
+                     format(self.name, self.host, self.port))
+
+        return True
+
+
 class PgBaseBackup(Command):
     def __init__(self, target_datadir, source_host, source_port, create_slot=False, replication_slot_name=None,
                  excludePaths=[], ctxt=LOCAL, remoteHost=None, forceoverwrite=False, target_gp_dbid=0,
-                 progress_file=None, recovery_mode=True):
+                 progress_file=None, recovery_mode=True, max_rate=None):
         cmd_tokens = ['pg_basebackup', '-c', 'fast']
         cmd_tokens.append('-D')
         cmd_tokens.append(target_datadir)
@@ -217,8 +277,19 @@ def __init__(self, target_datadir, source_host, source_port, create_slot=False,
         cmd_tokens.append('-p')
         cmd_tokens.append(source_port)
 
+        # if there is already slot present and create-slot arg is true it will give error,
+        # there is no option available in upstream postgres so that existing slot can be reused
+        # it's good choice to drop a existing available slot and recreate the new one
+        # if the slot does not already exist or drop slot is success we will create a new slot
+        # but if we are not able to drop the slot in that case,
+        # we will consider it as an error and will avoid creating a new slot
         if create_slot:
-            cmd_tokens.append('--create-slot')
+            pg_slot = PgReplicationSlot(source_host, source_port, replication_slot_name)
+            if pg_slot.slot_exists():
+                if pg_slot.drop_slot():
+                    cmd_tokens.append('--create-slot')
+            else:
+                cmd_tokens.append('--create-slot')
 
         cmd_tokens.extend(self._xlog_arguments(replication_slot_name))
 
@@ -253,6 +324,10 @@ def __init__(self, target_datadir, source_host, source_port, create_slot=False,
                 cmd_tokens.append('-E')
                 cmd_tokens.append(path)
 
+        if max_rate:
+            cmd_tokens.append('--max-rate')
+            cmd_tokens.append(max_rate)
+
         cmd_tokens.append('--progress')
         cmd_tokens.append('--verbose')
 
diff --git a/gpMgmt/bin/gppylib/commands/test/unit/test_unit_gp.py b/gpMgmt/bin/gppylib/commands/test/unit/test_unit_gp.py
index 4ac75c69685..c396c195e40 100644
--- a/gpMgmt/bin/gppylib/commands/test/unit/test_unit_gp.py
+++ b/gpMgmt/bin/gppylib/commands/test/unit/test_unit_gp.py
@@ -4,9 +4,9 @@
 #
 
 from gppylib.commands.base import CommandResult
-from mock import patch
+from mock import patch, mock_open
 
-from gppylib.commands.gp import is_pid_postmaster, get_postmaster_pid_locally
+from gppylib.commands.gp import is_pid_postmaster, get_postmaster_pid_locally, is_gprecoverseg_running
 from test.unit.gp_unittest import GpTestCase, run_tests
 
 
@@ -158,5 +158,21 @@ def test_get_postmaster_pid_locally_error(self, mock1):
     def test_get_postmaster_pid_locally_empty(self, mock1):
         self.assertEqual(get_postmaster_pid_locally('/tmp'), -1)
 
+    @patch('gppylib.commands.gp.check_pid', return_value=True)
+    @patch('gppylib.commands.gp.get_coordinatordatadir')
+    @patch("builtins.open", new_callable=mock_open, read_data="123")
+    def test_is_gprecoverseg_running_succeeds(self, mock_file, mock1, mock2):
+        result = is_gprecoverseg_running()
+        mock2.assert_called_once_with('123')
+        self.assertTrue(result)
+
+    @patch('gppylib.commands.gp.check_pid')
+    @patch('gppylib.commands.gp.get_coordinatordatadir', return_value='/invalid/path/')
+    def test_is_gprecoverseg_running_when_pidfile_does_not_exists(self, mock1, mock2):
+        result = is_gprecoverseg_running()
+        self.assertFalse(result)
+        self.assertFalse(mock2.called)
+
+
 if __name__ == '__main__':
     run_tests()
diff --git a/gpMgmt/bin/gppylib/commands/test/unit/test_unit_pg_base_backup.py b/gpMgmt/bin/gppylib/commands/test/unit/test_unit_pg_base_backup.py
index 117f62b41ea..2f45a87a547 100644
--- a/gpMgmt/bin/gppylib/commands/test/unit/test_unit_pg_base_backup.py
+++ b/gpMgmt/bin/gppylib/commands/test/unit/test_unit_pg_base_backup.py
@@ -1,4 +1,5 @@
 import unittest
+from mock import patch
 from gppylib.commands import pg
 
 
@@ -19,7 +20,9 @@ def test_replication_slot_not_passed_when_not_given_slot_name(self):
         self.assertIn("fetch", tokens)
         self.assertNotIn("stream", tokens)
 
-    def test_base_backup_passes_parameters_necessary_to_create_replication_slot_when_given_slotname(self):
+    @patch('gppylib.commands.pg.PgReplicationSlot.slot_exists', return_value=True)
+    @patch('gppylib.commands.pg.PgReplicationSlot.drop_slot', return_value=True)
+    def test_base_backup_passes_parameters_necessary_to_create_replication_slot_when_given_slotname(self, mock1, mock2):
         base_backup = pg.PgBaseBackup(
             create_slot=True,
             replication_slot_name='some-replication-slot-name',
@@ -32,8 +35,10 @@ def test_base_backup_passes_parameters_necessary_to_create_replication_slot_when
         self.assertIn("some-replication-slot-name", base_backup.command_tokens)
         self.assertIn("--wal-method", base_backup.command_tokens)
         self.assertIn("stream", base_backup.command_tokens)
+        self.assertIn("--create-slot", base_backup.command_tokens)
 
-    def test_base_backup_does_not_pass_conflicting_xlog_method_argument_when_given_replication_slot(self):
+    @patch('gppylib.commands.pg.PgReplicationSlot.slot_exists', return_value=False)
+    def test_base_backup_does_not_pass_conflicting_xlog_method_argument_when_given_replication_slot(self, mock1):
         base_backup = pg.PgBaseBackup(
             create_slot=True,
             replication_slot_name='some-replication-slot-name',
diff --git a/gpMgmt/bin/gppylib/commands/unix.py b/gpMgmt/bin/gppylib/commands/unix.py
index 4708b7ac574..b3f922bd2fe 100644
--- a/gpMgmt/bin/gppylib/commands/unix.py
+++ b/gpMgmt/bin/gppylib/commands/unix.py
@@ -55,16 +55,41 @@ def check_pid_on_remotehost(pid, host):
 
 
 def check_pid(pid):
-    """ Check For the existence of a unix pid. """
+    """
+    Check for the existence of a unix pid, meaning a process that is still
+    running.
+
+    os.kill(pid, 0) on its own is not that question: it keeps succeeding for a
+    process that has exited and has not been reaped, and nothing reaps an orphan
+    in a container started without an init, so such a zombie answers yes for the
+    life of the container. Every caller here is deciding whether something is
+    still working -- a postmaster, a utility holding a lock, a segment that was
+    just signalled -- and for all of them a zombie has gone.
+    """
+
+    try:
+        pid = int(pid)
+    except (TypeError, ValueError):
+        # A lock file that was created but never written leaves an empty PID
+        # behind; whatever wrote it is not running either way, and the callers
+        # ask this question to decide whether to clean up.
+        return False
 
     if pid == 0:
         return False
 
     try:
-        os.kill(int(pid), signal.SIG_DFL)
+        os.kill(pid, signal.SIG_DFL)
     except OSError:
         return False
-    else:
+
+    try:
+        with open('/proc/%d/stat' % pid) as statfile:
+            # The comm field is parenthesised and may itself contain spaces and
+            # parentheses, so state is the first field after the last ')'.
+            return statfile.read().rpartition(')')[2].split()[0] != 'Z'
+    except (IOError, OSError, IndexError, ValueError):
+        # No /proc to consult; the kill() above is the best answer available.
         return True
 
 
diff --git a/gpMgmt/bin/gppylib/mainUtils.py b/gpMgmt/bin/gppylib/mainUtils.py
index e947639591d..beaef5cd58f 100644
--- a/gpMgmt/bin/gppylib/mainUtils.py
+++ b/gpMgmt/bin/gppylib/mainUtils.py
@@ -307,13 +307,13 @@ def simple_main_internal(createOptionParserFn, createCommandFn, mainOptions):
 
     # at this point we have whatever lock we require
     try:
-        simple_main_locked(parserOptions, parserArgs, createCommandFn, mainOptions)
+        simple_main_locked(parser, parserOptions, parserArgs, createCommandFn, mainOptions)
     finally:
         if sml is not None:
             sml.release()
 
 
-def simple_main_locked(parserOptions, parserArgs, createCommandFn, mainOptions):
+def simple_main_locked(parser, parserOptions, parserArgs, createCommandFn, mainOptions):
     """
     Not to be called externally -- use simple_main instead
     """
@@ -326,7 +326,6 @@ def simple_main_locked(parserOptions, parserArgs, createCommandFn, mainOptions):
     faultProberInterface.registerFaultProber(faultProberImplGpdb.GpFaultProberImplGpdb())
 
     commandObject = None
-    parser = None
 
     forceQuiet = mainOptions is not None and mainOptions.get("forceQuietOutput")
 
diff --git a/gpMgmt/bin/gppylib/operations/buildMirrorSegments.py b/gpMgmt/bin/gppylib/operations/buildMirrorSegments.py
index 2e5212357d0..d7cb86bf822 100644
--- a/gpMgmt/bin/gppylib/operations/buildMirrorSegments.py
+++ b/gpMgmt/bin/gppylib/operations/buildMirrorSegments.py
@@ -135,7 +135,7 @@ class Action:
         ADDMIRRORS='add'
         RECOVERMIRRORS='recover'
 
-    def __init__(self, toBuild, pool, quiet, parallelDegree, additionalWarnings=None, logger=logger, forceoverwrite=False, progressMode=Progress.INPLACE, parallelPerHost=gp.DEFAULT_SEGHOST_NUM_WORKERS):
+    def __init__(self, toBuild, pool, quiet, parallelDegree, additionalWarnings=None, logger=logger, forceoverwrite=False, progressMode=Progress.INPLACE, parallelPerHost=gp.DEFAULT_SEGHOST_NUM_WORKERS, maxRate=None):
         self.__mirrorsToBuild = toBuild
         self.__pool = pool
         self.__quiet = quiet
@@ -144,6 +144,7 @@ def __init__(self, toBuild, pool, quiet, parallelDegree, additionalWarnings=None
         # true for gprecoverseg and gpmovemirrors; false for gpexpand and gpaddmirrors
         self.__forceoverwrite = forceoverwrite
         self.__parallelPerHost = parallelPerHost
+        self.__maxRate = maxRate
         self.__additionalWarnings = additionalWarnings or []
         self.segments_to_mark_down = []
         if not logger:
@@ -174,6 +175,12 @@ def getAdditionalWarnings(self):
         """
         return self.__additionalWarnings
 
+    def getMaxTransferRate(self):
+        """
+        returns the maximum transfer rate of data directory during Full recovery of failed segments
+        """
+        return self.__maxRate
+
     def _cleanup_before_recovery(self, gpArray, gpEnv):
         self.checkForPortAndDirectoryConflicts(gpArray)
         self._stop_failed_segments(gpEnv)
@@ -240,6 +247,9 @@ def __build_mirrors(self, actionName, gpEnv, gpArray):
 
         recovery_info_by_host = recoveryinfo.build_recovery_info(self.__mirrorsToBuild)
 
+        # Remove any existing progress files for segments to be recovered
+        self.remove_existing_progress_files(recovery_info_by_host)
+
         self._run_setup_recovery(actionName, recovery_info_by_host)
 
         backout_map = self._update_config(recovery_info_by_host, gpArray)
@@ -292,13 +302,17 @@ def _update_config(self, recovery_info_by_host, gpArray):
             signal.signal(signal.SIGINT, old_handler)
             return backout_map
 
-    def _remove_progress_files(self, recovery_info_by_host, recovery_results):
+    # Remove any existing progress file of segments that will be recovered by
+    # current gprecoverseg execution. The files written by this run are left in
+    # place: gpstate reads them to report progress, and they are what an
+    # operator looks at after a recovery that went wrong.
+    def remove_existing_progress_files(self, recovery_info_by_host):
         remove_progress_file_cmds = []
         for hostName, recovery_info_list in recovery_info_by_host.items():
             for ri in recovery_info_list:
-                if recovery_results.was_bb_rewind_successful(ri.target_segment_dbid):
-                    remove_progress_file_cmds.append(self._get_remove_cmd(ri.progress_file, hostName))
-        self.__runWaitAndCheckWorkerPoolForErrorsAndClear(remove_progress_file_cmds, suppressErrorCheck=False)
+                remove_progress_file_cmds.append(self._get_remove_cmd("*dbid{}.out".format(ri.target_segment_dbid),
+                                                                      hostName))
+        self.__runWaitAndCheckWorkerPoolForErrorsAndClear(remove_progress_file_cmds, suppressErrorCheck=True)
 
     def _revert_config_update(self, recovery_results, backout_map):
         if len(backout_map) == 0:
@@ -485,7 +499,6 @@ def _run_recovery(self, action_name, recovery_info_by_host, gpEnv):
         recovery_results = RecoveryResult(action_name, completed_recovery_results, self.__logger)
         recovery_results.print_bb_rewind_and_start_errors()
 
-        self._remove_progress_files(recovery_info_by_host, recovery_results)
         return recovery_results
 
     def _do_recovery(self, recovery_info_by_host, gpEnv):
@@ -517,6 +530,7 @@ def _do_recovery(self, recovery_info_by_host, gpEnv):
                                          batchSize=self.__parallelPerHost,
                                          remoteHost=hostName,
                                          era=era,
+                                         maxRate=self.__maxRate,
                                          forceoverwrite=self.__forceoverwrite))
         completed_recovery_results = self.__runWaitAndCheckWorkerPoolForErrorsAndClear(cmds, suppressErrorCheck=True,
                                                                                        progressCmds=progress_cmds)
diff --git a/gpMgmt/bin/gppylib/operations/rebalanceSegments.py b/gpMgmt/bin/gppylib/operations/rebalanceSegments.py
index a46f0d69d13..a87fdd81340 100644
--- a/gpMgmt/bin/gppylib/operations/rebalanceSegments.py
+++ b/gpMgmt/bin/gppylib/operations/rebalanceSegments.py
@@ -1,5 +1,6 @@
 import sys
 import signal
+from contextlib import closing
 from gppylib.gparray import GpArray
 from gppylib.db import dbconn
 from gppylib.commands.gp import GpSegStopCmd
@@ -10,6 +11,43 @@
 
 MIRROR_PROMOTION_TIMEOUT=600
 
+logger = gplog.get_default_logger()
+
+
+# cherry-pick from Greenplum Database
+# greenplum-db/gpdb-archive @ 482967c1b4,
+# gpMgmt/bin/gppylib/operations/rebalanceSegments.py
+def replay_lag(primary_db):
+    """
+    This function returns replay lag (diff of flush_lsn and replay_lsn) on mirror segment. Goal being if there is a
+    lot to catchup on mirror the user should be warned about that and rebalance opertion should be aborted.
+    params: primary segment info
+    return value: replay lag in bytes
+    replay lag in bytes: diff of flush_lsn and replay_lsn on mirror
+    """
+    port = primary_db.getSegmentPort()
+    host = primary_db.getSegmentHostName()
+    logger.debug('Get replay lag on mirror of primary segment with host:{}, port:{}'.format(host, port))
+    sql = "select pg_wal_lsn_diff(flush_lsn, replay_lsn) from pg_stat_replication;"
+
+    try:
+        dburl = dbconn.DbURL(hostname=host, port=port)
+        with closing(dbconn.connect(dburl, utility=True, encoding='UTF8')) as conn:
+            replay_lag = dbconn.querySingleton(conn, sql)
+    except Exception as ex:
+        raise Exception("Failed to query pg_stat_replication for host:{}, port:{}, error: {}".
+                        format(host, port, str(ex)))
+
+    # flush_lsn and replay_lsn are nullable -- a walsender that has connected
+    # but not yet reported leaves pg_wal_lsn_diff() NULL. Upstream hands that
+    # straight to float(), which dies with a bare TypeError in the middle of a
+    # rebalance; say what actually happened instead.
+    if replay_lag is None:
+        raise Exception("Could not read the replay lag on the mirror of the segment with host:{}, port:{}: "
+                        "the walsender has not reported a flush or replay position yet".format(host, port))
+
+    return replay_lag
+
 
 class ReconfigDetectionSQLQueryCommand(base.SQLCommand):
     """A distributed query that will cause the system to detect
@@ -26,11 +64,13 @@ def run(self):
 
 
 class GpSegmentRebalanceOperation:
-    def __init__(self, gpEnv, gpArray, batch_size, segment_batch_size):
+    def __init__(self, gpEnv, gpArray, batch_size, segment_batch_size, disable_replay_lag, replay_lag):
         self.gpEnv = gpEnv
         self.gpArray = gpArray
         self.batch_size = batch_size
         self.segment_batch_size = segment_batch_size
+        self.disable_replay_lag = disable_replay_lag
+        self.replay_lag = replay_lag
         self.logger = gplog.get_default_logger()
 
     def rebalance(self):
@@ -45,6 +85,17 @@ def rebalance(self):
                 continue
 
             if segmentPair.up() and segmentPair.reachable() and segmentPair.synchronized():
+
+                if not self.disable_replay_lag:
+                    self.logger.info("Allowed replay lag during rebalance is {} GB".format(self.replay_lag))
+                    replay_lag_in_bytes = replay_lag(segmentPair.primaryDB)
+                    if float(replay_lag_in_bytes) >= (self.replay_lag * 1024 * 1024 * 1024):
+                        raise Exception("{} bytes of wal is still to be replayed on mirror with dbid {}, let "
+                                        "mirror catchup on replay then trigger rebalance. Use --replay-lag to "
+                                        "configure the allowed replay lag limit or --disable-replay-lag to disable"
+                                        " the check completely if you wish to continue with rebalance anyway"
+                                        .format(replay_lag_in_bytes, segmentPair.primaryDB.getSegmentDbId()))
+
                 unbalanced_primary_segs.append(segmentPair.primaryDB)
             else:
                 self.logger.warning(
diff --git a/gpMgmt/bin/gppylib/operations/test/unit/test_unit_buildMirrorSegments.py b/gpMgmt/bin/gppylib/operations/test/unit/test_unit_buildMirrorSegments.py
index 61a88c21539..f1e00941225 100644
--- a/gpMgmt/bin/gppylib/operations/test/unit/test_unit_buildMirrorSegments.py
+++ b/gpMgmt/bin/gppylib/operations/test/unit/test_unit_buildMirrorSegments.py
@@ -105,9 +105,9 @@ def _setup_build_mirrors_mocks(self, build_mirrors_obj):
 
     def _setup_recovery_mocks(self, host_errors=[]):
         host1_recovery_output = gp.GpSegRecovery('test recover 1', 'dummy_info1', '/tmp/log1/', False, 1,
-                                                 'host1', 'dummy_era1', True)
+                                                 'host1', 'dummy_era1', True, None)
         host2_recovery_output = gp.GpSegRecovery('test recover 2', 'dummy_info2', '/tmp/log2/', True, 2,
-                                                 'host2', 'dummy_era2', False)
+                                                 'host2', 'dummy_era2', False, None)
 
         host1_result = CommandResult(0, ''.encode(), ''.encode(), True, False)
         host2_result = CommandResult(0, ''.encode(), ''.encode(), True, False)
diff --git a/gpMgmt/bin/gppylib/programs/clsRecoverSegment.py b/gpMgmt/bin/gppylib/programs/clsRecoverSegment.py
index 81377136f83..d3a8b323744 100644
--- a/gpMgmt/bin/gppylib/programs/clsRecoverSegment.py
+++ b/gpMgmt/bin/gppylib/programs/clsRecoverSegment.py
@@ -19,7 +19,7 @@
 from gppylib.mainUtils import *
 
 from optparse import OptionGroup
-import glob, os, sys, signal, shutil, time
+import glob, os, re, sys, signal, shutil, time
 from contextlib import closing
 
 from gppylib import gparray, gplog, userinput, utils
@@ -46,6 +46,13 @@
 
 logger = gplog.get_default_logger()
 
+# cherry-pick from Greenplum Database
+# greenplum-db/gpdb-archive @ 482967c1b4,
+# gpMgmt/bin/gppylib/programs/clsRecoverSegment.py
+# Upper bound and lower bound for max-rate
+MAX_RATE_LOWER = 32
+MAX_RATE_UPPER = 1048576
+
 # -------------------------------------------------------------------------
 
 class RemoteQueryCommand(Command):
@@ -122,7 +129,9 @@ def outputToFile(self, mirrorBuilder, gpArray, fileName):
 
     def getRecoveryActionsBasedOnOptions(self, gpEnv, gpArray):
         if self.__options.rebalanceSegments:
-            return GpSegmentRebalanceOperation(gpEnv, gpArray, self.__options.parallelDegree, self.__options.parallelPerHost)
+            return GpSegmentRebalanceOperation(gpEnv, gpArray, self.__options.parallelDegree,
+                                               self.__options.parallelPerHost, self.__options.disableReplayLag,
+                                               self.__options.replayLag)
         else:
             instance = RecoveryTripletsFactory.instance(gpArray, self.__options.recoveryConfigFile, self.__options.newRecoverHosts)
             segs = [GpMirrorToBuild(t.failed, t.live, t.failover, self.__options.forceFullResynchronization) for t in instance.getTriplets()]
@@ -131,7 +140,8 @@ def getRecoveryActionsBasedOnOptions(self, gpEnv, gpArray):
                                        instance.getInterfaceHostnameWarnings(),
                                        forceoverwrite=True,
                                        progressMode=self.getProgressMode(),
-                                       parallelPerHost=self.__options.parallelPerHost)
+                                       parallelPerHost=self.__options.parallelPerHost,
+                                       maxRate=self.__options.maxRate)
 
     def syncPackages(self, new_hosts):
         # The design decision here is to squash any exceptions resulting from the
@@ -196,6 +206,10 @@ def displayRecovery(self, mirrorBuilder, gpArray):
                                                               toRecover.getFailoverSegment(), tabLog)
                 else:
                     tabLog.info(["Recovery Target", "= in-place"])
+
+                if syncMode == "Full" and mirrorBuilder.getMaxTransferRate() is not None:
+                    tabLog.info(["Maximum Transfer Rate", "= " + mirrorBuilder.getMaxTransferRate()])
+
                 tabLog.outputTable()
 
                 i = i + 1
@@ -229,6 +243,14 @@ def _getRecoveryWarnings(self, mirrorBuilder):
                                "primary %s    failover target: %s"
                                % (self.__getSimpleSegmentLabel(src), self.__getSimpleSegmentLabel(dest)))
 
+            if not toRecover.isFullSynchronization() and mirrorBuilder.getMaxTransferRate() is not None:
+                #
+                # For Incremental recovery, when max-rate option is provided,
+                # warn the user that only Full recovery supports max-rate option
+                #
+                res.append(" --max-rate flag is only supported with segments undergoing Full recovery (-F). "
+                           "Other modes of recovery will use the entire available network bandwidth.")
+
         for warning in mirrorBuilder.getAdditionalWarnings():
             res.append(warning)
 
@@ -240,6 +262,46 @@ def _get_dblist(self):
             res = dbconn.query(conn, "SELECT datname FROM PG_DATABASE WHERE datname != 'template0'")
             return res.fetchall()
 
+    # cherry-pick from Greenplum Database
+    # greenplum-db/gpdb-archive @ 482967c1b4,
+    # gpMgmt/bin/gppylib/programs/clsRecoverSegment.py
+    def validateMaxRate(self):
+        """
+        Validate the max-rate input provided by the user.
+        Numeric part of max-rate can be a whole/decimal number with an optional suffix of either 'k' or 'M'
+        Valid range is from 32kbps to 1048576kbps(1024Mbps)
+
+        Below regex pattern validates the max-rate which can be a whole/decimal number with an optional unit suffix.
+        Valid match patterns - '12', '12.34A', '123.45'
+        Invalid match patterns - ABC', '.', '12 34'
+
+        """
+        # (\d+(?:\.\d+)?), not ([\d\.]+): the looser upstream form also matches
+        # '.', '...' and '1.2.3', which float() then rejects with a ValueError
+        # that escapes this function -- the operator gets "could not convert
+        # string to float" instead of the message below. The docstring above
+        # already calls '.' invalid; this makes the pattern agree with it.
+        pattern = r'^\s*(\d+(?:\.\d+)?)([a-zA-Z]?)\s*$'
+        match = re.match(pattern, self.__options.maxRate)
+
+        if match:
+            rateVal, rateSuffix = match.groups()
+
+            rateVal = float(rateVal)
+            if(rateVal <= 0):
+                raise ProgramArgumentValidationException("Transfer rate must be greater than zero")
+
+            if rateSuffix == 'M':
+               rateVal *= 1024
+            elif rateSuffix and rateSuffix != 'k':
+               raise ProgramArgumentValidationException("Invalid --max-rate unit: {0}".format(rateSuffix))
+
+            if rateVal < MAX_RATE_LOWER or rateVal > MAX_RATE_UPPER:
+                raise ProgramArgumentValidationException("transfer rate {0} is out of range".format(self.__options.maxRate))
+        else:
+            raise ProgramArgumentValidationException("transfer rate {0} is not a valid value".format(self.__options.maxRate))
+        return
+
     def run(self):
         if self.__options.parallelDegree < 1 or self.__options.parallelDegree > gp.MAX_COORDINATOR_NUM_WORKERS:
             raise ProgramArgumentValidationException(
@@ -262,6 +324,38 @@ def run(self):
         if optionCnt > 1:
             raise ProgramArgumentValidationException("Only one of -i, -p, and -r may be specified")
 
+        # -o only writes out a sample configuration file describing what would
+        # be recovered; it does not recover anything, so combining it with an
+        # option that says where to recover to is a contradiction rather than a
+        # refinement.
+        if self.__options.outputSampleConfigFile:
+            if self.__options.recoveryConfigFile is not None:
+                raise ProgramArgumentValidationException("Invalid -i provided with -o argument")
+            if self.__options.rebalanceSegments:
+                raise ProgramArgumentValidationException("Invalid -r provided with -o argument")
+
+        if self.__options.disableReplayLag and not self.__options.rebalanceSegments:
+            raise ProgramArgumentValidationException("--disable-replay-lag should be used only with -r")
+
+        # A full resynchronisation rebuilds the mirror from its primary, which
+        # is neither what -r (rebalance back to preferred roles) nor -p
+        # (recover onto a different host) asks for.
+        if self.__options.forceFullResynchronization:
+            if self.__options.rebalanceSegments:
+                raise ProgramArgumentValidationException("-F option is not supported with -r option")
+            if self.__options.newRecoverHosts is not None:
+                raise ProgramArgumentValidationException("-F option is not supported with -p option")
+
+        # Verify max-rate supported options
+        if self.__options.maxRate and self.__options.rebalanceSegments:
+            self.logger.warn(" -r flag does not support the use of --max-rate, hence --max-rate will be ignored")
+        if self.__options.outputSampleConfigFile and self.__options.maxRate:
+            self.logger.warn(" -o flag does not support the use of --max-rate, hence --max-rate will be ignored")
+
+        # Validate max-rate value, if provided as an option
+        if self.__options.maxRate:
+            self.validateMaxRate()
+
         faultProberInterface.getFaultProber().initializeProber(gpEnv.getCoordinatorPort())
 
         confProvider = configInterface.getConfigurationProvider().initializeProvider(gpEnv.getCoordinatorPort())
@@ -378,12 +472,16 @@ def signal_handler(sig, frame):
             if not mirrorBuilder.recover_mirrors(gpEnv, gpArray):
                 if self.termination_requested:
                     self.logger.error("gprecoverseg process was interrupted by the user.")
+                self.logger.error("gprecoverseg failed. Please check the output for more details.")
                 sys.exit(1)
 
             if self.termination_requested:
                 self.logger.info("Not able to terminate the recovery process since it has been completed successfully.")
 
             self.logger.info("********************************")
+            self.logger.info("Future gprecoverseg executions might remove the currently created pg_basebackup/pg_rewind/rsync "
+                             "progress files, please save these files if needed.")
+            self.logger.info("********************************")
             self.logger.info("Segments successfully recovered.")
             self.logger.info("********************************")
 
@@ -500,8 +598,15 @@ def createParser():
 
         addTo.add_option("-r", None, default=False, action='store_true',
                          dest='rebalanceSegments', help='Rebalance synchronized segments.')
+        addTo.add_option("--replay-lag", None, type="float", default=gp.ALLOWED_REPLAY_LAG,
+                         dest="replayLag",
+                         metavar="<replayLag>", help='Allowed replay lag on mirror, lag should be provided in GBs')
+        addTo.add_option("--disable-replay-lag", None, default=False, action='store_true',
+                         dest='disableReplayLag', help='Disable replay lag check when rebalancing segments')
         addTo.add_option('', '--hba-hostnames', action='store_true', dest='hba_hostnames',
                          help='use hostnames instead of CIDR in pg_hba.conf')
+        addTo.add_option('--max-rate', type='string', dest='maxRate', metavar='<maxRate>',
+                          help='Maximum Rate of data transfer')
 
         parser.set_defaults()
         return parser
diff --git a/gpMgmt/bin/gppylib/programs/clsRecoverSegment_triples.py b/gpMgmt/bin/gppylib/programs/clsRecoverSegment_triples.py
index 34b6a12ff2e..674387f9807 100644
--- a/gpMgmt/bin/gppylib/programs/clsRecoverSegment_triples.py
+++ b/gpMgmt/bin/gppylib/programs/clsRecoverSegment_triples.py
@@ -1,11 +1,99 @@
 import abc
 from typing import List
 
+from contextlib import closing
+from gppylib.db import dbconn
+from gppylib import gplog
 from gppylib.mainUtils import ExceptionNoStackTraceNeeded
 from gppylib.operations.detect_unreachable_hosts import get_unreachable_segment_hosts
 from gppylib.parseutils import line_reader, check_values, canonicalize_address
-from gppylib.utils import checkNotNone, normalizeAndValidateInputPath
+from gppylib.utils import checkNotNone, normalizeAndValidateInputPath, validateHostnameAddress
 from gppylib.gparray import GpArray, Segment
+from gppylib.commands.gp import RECOVERY_REWIND_APPNAME
+
+logger = gplog.get_default_logger()
+
+
+# cherry-pick from Greenplum Database
+# greenplum-db/gpdb-archive @ 482967c1b4,
+# gpMgmt/bin/gppylib/programs/clsRecoverSegment_triples.py
+def get_segments_with_running_basebackup():
+    """
+    Returns a list of contentIds of source segments of running pg_basebackup processes
+    At present gp_stat_replication table does not contain any info about datadir and dbid of the target of running pg_basebackup
+    """
+
+    sql = "select gp_segment_id from gp_stat_replication where application_name = 'pg_basebackup'"
+
+    try:
+        with closing(dbconn.connect(dbconn.DbURL())) as conn:
+            res = dbconn.query(conn, sql)
+            rows = res.fetchall()
+    except Exception as e:
+        raise Exception("Failed to query gp_stat_replication: %s" %str(e))
+
+    segments_with_running_basebackup = {row[0] for row in rows}
+
+    if len(segments_with_running_basebackup) == 0:
+        logger.debug("No basebackup running")
+    return segments_with_running_basebackup
+
+
+# cherry-pick from Greenplum Database
+# greenplum-db/gpdb-archive @ 482967c1b4,
+# gpMgmt/bin/gppylib/programs/clsRecoverSegment_triples.py
+def is_pg_rewind_running(hostname, port):
+    """
+        Returns true if a pg_rewind process is running for the given segment
+    """
+    logger.debug(
+        "Checking for running instances of pg_rewind with host {} and port {} as source server".format(hostname, port))
+
+    """
+        Reasons to depend on pg_stat_activity table:
+            * pg_rewind is invoked using --source-server connection string as it needs libpq connection
+              with source server, which will be remote to the target server and --source-pgdata can not
+              be used in that case. Thus pg_stat_activity will always contain entry for active pg_rewind.
+            * pg_rewind keeps a connection open throughout it's lifecycle, so pg_stat_activity will contain
+              entries for active pg_rewind process till the end of execution.
+            * gpstate uses the above mentioned approach (pg_stat_activity entry check) to check for
+              incremental recoveries in progress.Thus, using the same approach will make it consistent
+              everywhere.
+    """
+
+    sql = "SELECT count(*) FROM pg_stat_activity WHERE application_name = '{}'".format(RECOVERY_REWIND_APPNAME)
+    try:
+        url = dbconn.DbURL(hostname=hostname, port=port, dbname='template1')
+        with closing(dbconn.connect(url, utility=True)) as conn:
+            res = dbconn.querySingleton(conn, sql)
+            return res > 0
+
+    except Exception as e:
+        raise Exception("Failed to query pg_stat_activity for segment hostname: {}, port: {}, error: {}".format(
+            hostname, str(port), str(e)))
+
+
+# cherry-pick from Greenplum Database
+# greenplum-db/gpdb-archive @ 482967c1b4,
+# gpMgmt/bin/gppylib/programs/clsRecoverSegment_triples.py
+def extract_recovery_config_info(parts):
+    """
+    Extracts relevant recovery configuration information from a list of parts.
+
+    Three parts is the historical form, "<address>|<port>|<datadir>", and the
+    hostname is taken to be the address. Four parts puts an explicit hostname
+    first; it is then cross-checked against the address, and against the
+    hostname the segment is registered under.
+    """
+    address, port, datadir = parts[-3:]
+    hostname_check_required = False
+    hostname = address
+
+    if len(parts) == 4:
+        hostname = parts[0]
+        hostname_check_required = True
+
+    return hostname, address, port, datadir, hostname_check_required
 
 
 class RecoveryTriplet:
@@ -84,10 +172,12 @@ def validate(failed, live, failover):
 
 
 class RecoveryTripletRequest:
-    def __init__(self, failed, failover_host=None, failover_port=None, failover_datadir=None, is_new_host=False):
+    def __init__(self, failed, failover_host_name=None, failover_host_address=None, failover_port=None,
+                 failover_datadir=None, is_new_host=False):
         self.failed = failed
 
-        self.failover_host = failover_host
+        self.failover_host_name = failover_host_name
+        self.failover_host_address = failover_host_address
         self.failover_port = failover_port
         self.failover_datadir = failover_datadir
         self.failover_to_new_host = is_new_host
@@ -142,12 +232,36 @@ def _convert_requests_to_triplets(self, requests: List[RecoveryTripletRequest])
         triplets = []
 
         dbIdToPeerMap = self.gpArray.getDbIdToPeerMap()
+
+        failed_segments_with_running_basebackup = []
+        failed_segments_with_running_pgrewind = []
+        segments_with_running_basebackup = get_segments_with_running_basebackup()
+
         for req in requests:
+            """
+                When running gprecoverseg (any sort of recovery full/incremental), if the pg_rewind, pg_basebackup is
+                already running for a segment, that segment should be skipped from the recovery. The reason being that
+                there should be only one writer per target segment at a time. Having several writers to a target will
+                eventually make the segment inconsistent and in a weird state.
+
+                Although technically we could allow user to run a full recovery to a new host even if there is a
+                pg_rewind/pg_basebackup running for that segment. This is a pretty rare scenario and we have decided not
+                to over complicates the code just to support this scenario.
+            """
+            # The peer has to be looked up before the failover block below, which
+            # replaces req.failed with a copy; the dbid is the same either way,
+            # but the lookup is needed here to decide whether to skip at all.
+            failed_segment_dbid = req.failed.getSegmentDbId()
+            peer = dbIdToPeerMap.get(failed_segment_dbid)
+            if peer is None:
+                raise Exception("No peer found for dbid {}. liveSegment is None".format(failed_segment_dbid))
+            peer_contentid = peer.getSegmentContentId()
+
             # TODO: These 2 cases have different behavior which might be confusing to the user.
             # "<failed_address>|<failed_port>|<failed_data_dir> <failed_address>|<failed_port>|<failed_data_dir>" does full recovery
             # "<failed_address>|<failed_port>|<failed_data_dir>" does incremental recovery
             failover = None
-            if req.failover_host:
+            if req.failover_host_address:
 
                 # these two lines make it so that failover points to the object that is registered in gparray
                 #   as the failed segment(!).
@@ -155,8 +269,17 @@ def _convert_requests_to_triplets(self, requests: List[RecoveryTripletRequest])
                 req.failed = failover.copy()
 
                 # now update values in failover segment
-                failover.setSegmentAddress(req.failover_host)
-                failover.setSegmentHostName(req.failover_host)
+                if req.failover_host_name != req.failover_host_address:
+                    # Validate if the hostname and address are of the same host
+                    if not validateHostnameAddress(req.failover_host_name, req.failover_host_address):
+                        logger.warning(
+                            "Not able to co-relate hostname:{0} with address:{1}. "
+                            "Skipping recovery for segments with contentId {2}"
+                            .format(req.failover_host_name, req.failover_host_address, peer_contentid))
+                        continue
+
+                failover.setSegmentHostName(req.failover_host_name)
+                failover.setSegmentAddress(req.failover_host_address)
                 failover.setSegmentPort(int(req.failover_port))
                 failover.setSegmentDataDirectory(req.failover_datadir)
                 failover.unreachable = False if req.failover_to_new_host else failover.unreachable
@@ -166,10 +289,32 @@ def _convert_requests_to_triplets(self, requests: List[RecoveryTripletRequest])
             if req.failed.unreachable and not req.failover_to_new_host:
                 continue
 
-            peer = dbIdToPeerMap.get(req.failed.getSegmentDbId())
+            # Only now, once this segment is actually going to be recovered.
+            # is_pg_rewind_running() connects to the peer, and on a double
+            # fault -- failed segment and peer both down -- that connection
+            # raises. Asked before the skip above, it would abort the whole
+            # gprecoverseg run rather than skip the one segment, which is the
+            # opposite of what is wanted when a cluster is already degraded.
+            if peer_contentid in segments_with_running_basebackup:
+                failed_segments_with_running_basebackup.append(peer_contentid)
+                continue
+
+            if is_pg_rewind_running(peer.getSegmentHostName(), peer.getSegmentPort()):
+                failed_segments_with_running_pgrewind.append(peer_contentid)
+                continue
 
             triplets.append(RecoveryTriplet(req.failed, peer, failover))
 
+        if len(failed_segments_with_running_basebackup) > 0:
+            logger.warning(
+                "Found pg_basebackup running for segments with contentIds %s, skipping recovery of these segments" % (
+                    failed_segments_with_running_basebackup))
+
+        if len(failed_segments_with_running_pgrewind) > 0:
+            logger.warning(
+                "Found pg_rewind running for segments with contentIds %s, skipping recovery of these segments" % (
+                    failed_segments_with_running_pgrewind))
+
         return triplets
 
 
@@ -222,7 +367,11 @@ def _check_new_hosts():
         for failedHost, failoverHost in zip(sorted(failedSegments.keys()), self.newHosts):
             for failed in failedSegments[failedHost]:
                 failoverPort = self.portAssigner.findAndReservePort(failoverHost, failoverHost)
-                req = RecoveryTripletRequest(failed, failoverHost, failoverPort, failed.getSegmentDataDirectory(), True)
+                req = RecoveryTripletRequest(failed, failover_host_name=failoverHost,
+                                             failover_host_address=failoverHost,
+                                             failover_port=failoverPort,
+                                             failover_datadir=failed.getSegmentDataDirectory(),
+                                             is_new_host=True)
                 requests.append(req)
 
         return self._convert_requests_to_triplets(requests)
@@ -285,6 +434,11 @@ def getTriplets(self):
         def _find_failed_from_row():
             failed = None
             for segment in self.gpArray.getDbList():
+                # When the input configuration file carries an explicit hostname
+                # it has to match the one the segment is registered under, or
+                # this is not the segment the operator meant.
+                if row['hostname_check_required'] and segment.getSegmentHostName() != row['failedHostname']:
+                    continue
                 if (segment.getSegmentAddress() == row['failedAddress']
                         and str(segment.getSegmentPort()) == row['failedPort']
                         and segment.getSegmentDataDirectory() == row['failedDataDirectory']):
@@ -292,15 +446,32 @@ def _find_failed_from_row():
                     break
 
             if failed is None:
-                raise Exception("A segment to recover was not found in configuration.  " \
-                                "This segment is described by address|port|directory '%s|%s|%s'" %
-                                (row['failedAddress'], row['failedPort'], row['failedDataDirectory']))
+                # Keep Cloudberry's wording -- the two spaces and the names of
+                # the fields -- rather than upstream's terser form. It tells
+                # the operator which field is which, and the scenario that
+                # covers this asserts on it literally.
+                msg = "A segment to recover was not found in configuration.  " \
+                      "This segment is described by "
+                if row['hostname_check_required']:
+                    msg += "hostname|address|port|directory '{}|{}|{}|{}'".format(
+                        row['failedHostname'], row['failedAddress'],
+                        row['failedPort'], row['failedDataDirectory'])
+                else:
+                    msg += "address|port|directory '{}|{}|{}'".format(
+                        row['failedAddress'], row['failedPort'],
+                        row['failedDataDirectory'])
+
+                raise Exception(msg)
 
             return failed
 
         requests = []
         for row in self.rows:
-            req = RecoveryTripletRequest(_find_failed_from_row(), row.get('newAddress'), row.get('newPort'), row.get('newDataDirectory'))
+            req = RecoveryTripletRequest(_find_failed_from_row(),
+                                         failover_host_name=row.get('newHostname'),
+                                         failover_host_address=row.get('newAddress'),
+                                         failover_port=row.get('newPort'),
+                                         failover_datadir=row.get('newDataDirectory'))
             requests.append(req)
 
         return self._convert_requests_to_triplets(requests)
@@ -322,31 +493,43 @@ def _parseConfigFile(config_file):
                     msg = "line %d of file %s: expected 1 or 2 groups but found %d" % (lineno, config_file, len(groups))
                     raise ExceptionNoStackTraceNeeded(msg)
                 parts = groups[0].split('|')
-                if len(parts) != 3:
-                    msg = "line %d of file %s: expected 3 parts on failed segment group, obtained %d" % (
+
+                if len(parts) not in {3, 4}:
+                    msg = "line {0} of file {1}: expected 3 or 4 parts on failed segment group, obtained {2}" .format(
                         lineno, config_file, len(parts))
                     raise ExceptionNoStackTraceNeeded(msg)
-                address, port, datadir = parts
-                check_values(lineno, address=address, port=port, datadir=datadir)
+
+                hostname, address, port, datadir, hostname_check_required = extract_recovery_config_info(parts)
+
+                check_values(lineno, hostname=hostname, address=address, port=port, datadir=datadir)
                 datadir = normalizeAndValidateInputPath(datadir, f.name, lineno)
 
                 row = {
+                    'failedHostname': hostname,
                     'failedAddress': address,
                     'failedPort': port,
                     'failedDataDirectory': datadir,
-                    'lineno': lineno
+                    'lineno': lineno,
+                    'hostname_check_required': hostname_check_required
                 }
                 if len(groups) == 2:
                     parts2 = groups[1].split('|')
-                    if len(parts2) != 3:
-                        msg = "line %d of file %s: expected 3 parts on new segment group, obtained %d" % (
-                            lineno, config_file, len(parts2))
+                    if len(parts2) not in [3, 4] or len(parts) != len(parts2):
+                        msg = "line {0} of file {1}: expected equal parts, either 3 or 4 on both segment group, obtained {2} on " \
+                              "group1 and {3} on group2" .format(
+                            lineno, config_file, len(parts), len(parts2))
                         raise ExceptionNoStackTraceNeeded(msg)
-                    address2, port2, datadir2 = parts2
-                    check_values(lineno, address=address2, port=port2, datadir=datadir2)
+                    if len(parts2) == 4:
+                        hostname2, address2, port2, datadir2 = parts2
+                    else:
+                        address2, port2, datadir2 = parts2
+                        hostname2 = address2
+
+                    check_values(lineno, hostname=hostname2, address=address2, port=port2, datadir=datadir2)
                     datadir2 = normalizeAndValidateInputPath(datadir2, f.name, lineno)
 
                     row.update({
+                        'newHostname': hostname2,
                         'newAddress': address2,
                         'newPort': port2,
                         'newDataDirectory': datadir2
diff --git a/gpMgmt/bin/gppylib/programs/clsSystemState.py b/gpMgmt/bin/gppylib/programs/clsSystemState.py
index e234b633122..2434adb955d 100644
--- a/gpMgmt/bin/gppylib/programs/clsSystemState.py
+++ b/gpMgmt/bin/gppylib/programs/clsSystemState.py
@@ -22,7 +22,6 @@
 from gppylib.system import configurationInterface as configInterface
 from gppylib.system.environment import GpCoordinatorEnvironment
 from gppylib.utils import TableLogger
-from gppylib.commands.gp import get_coordinatordatadir
 
 logger = gplog.get_default_logger()
 
@@ -682,15 +681,18 @@ def logSegments(segments, logAsPairs, additionalFieldsToLog=[]):
 
         self.__addClusterDownWarning(gpArray, data)
 
-        recovery_progress_file = get_recovery_progress_file(gplog)
-        segments_under_recovery = self._parse_recovery_progress_data(data, recovery_progress_file, gpArray)
-        gprecoverseg_lock_dir = os.path.join(get_coordinatordatadir() + '/gprecoverseg.lock')
-        if segments_under_recovery and os.path.exists(gprecoverseg_lock_dir):
-            logger.info("----------------------------------------------------")
-            logger.info("Segments in recovery")
-            logSegments(segments_under_recovery, False, [VALUE_RECOVERY_TYPE, VALUE_RECOVERY_COMPLETED_BYTES, VALUE_RECOVERY_TOTAL_BYTES,
-                                                          VALUE_RECOVERY_PERCENTAGE])
-            exitCode = 1
+        # Check if gprecoverseg process is running. We do not want to
+        # show the progress if the gprecoverseg process is not running.
+        if gp.is_gprecoverseg_running():
+            recovery_progress_file = get_recovery_progress_file(gplog)
+            segments_under_recovery = self._parse_recovery_progress_data(data, recovery_progress_file, gpArray)
+
+            if segments_under_recovery:
+                logger.info("----------------------------------------------------")
+                logger.info("Segments in recovery")
+                logSegments(segments_under_recovery, False, [VALUE_RECOVERY_TYPE, VALUE_RECOVERY_COMPLETED_BYTES,
+                                                             VALUE_RECOVERY_TOTAL_BYTES, VALUE_RECOVERY_PERCENTAGE])
+                exitCode = 1
 
         # final output -- no errors, then log this message
         if exitCode == 0:
diff --git a/gpMgmt/bin/gppylib/recoveryinfo.py b/gpMgmt/bin/gppylib/recoveryinfo.py
index f13ea81394b..b4530bc2194 100644
--- a/gpMgmt/bin/gppylib/recoveryinfo.py
+++ b/gpMgmt/bin/gppylib/recoveryinfo.py
@@ -1,8 +1,10 @@
 from collections import defaultdict
 import datetime
 import json
+import shlex
 
 from gppylib import gplog
+from gppylib.commands.base import Command, REMOTE
 
 
 class RecoveryInfo(object):
@@ -169,8 +171,36 @@ def print_setup_recovery_errors(self):
                     self._logger.error(setup_recovery_error_pattern.format(hostname, error.port, error.error_msg))
         self._print_invalid_errors()
 
+    # Cherry-picked from Greenplum Database (greenplum-db/gpdb-archive @ 482967c1b4),
+    # gpMgmt/bin/gppylib/recoveryinfo.py, with the line it filters out
+    # changed: pg_rewind reports its own failure differently since
+    # PostgreSQL 13. See the comment in the body.
+    def get_error_from_logfile(self, progress_file, hostname):
+        """
+        Traverse the error file to fetch last registered occurrence of 'error, panic or fatal'.
+        pg_rewind logs a line of its own after every failed attempt, which is
+        never the reason for the failure -- the reason is whatever the backend
+        wrote just above it -- so that line is excluded. Upstream excludes
+        PostgreSQL 12's wording of it, "fatal: postgres single-user mode of
+        target instance failed for command"; since 13 pg_rewind writes
+        "error: postgres single-user mode in target cluster failed" followed by
+        a separate "detail: Command was: ...", and only the first of those two
+        carries a word this grep looks for.
+        To ensure grep doesn't return a non-zero exit code, it is ORed with true.
+        """
+        cmdStr = r'set -o pipefail; cat {} | (grep -i "ERROR\|PANIC\|FATAL" | grep -v "error: postgres single-user mode in target cluster failed" || true) | tail -1'.format(
+            shlex.quote(progress_file))
+        cmd = Command(name="Parse logfile for errors on a remote host", cmdStr=cmdStr, ctxt=REMOTE, remoteHost=hostname)
+        cmd.run()
+
+        if cmd.get_results().rc != 0:
+            self._logger.debug("Failed while parsing the logfile %s" % progress_file)
+            return None
+
+        return cmd.get_results().stdout.strip()
+
     def print_bb_rewind_and_start_errors(self):
-        bb_rewind_error_pattern = " hostname: {}; port: {}; logfile: {}; recoverytype: {}"
+        bb_rewind_error_pattern = " hostname: {}; port: {}; logfile: {}; recoverytype: {}; error: {}"
         if len(self._bb_errors) > 0 or len(self._rewind_errors) > 0:
             self._logger.info("----------------------------------------------------------")
             if len(self._rewind_errors) > 0:
@@ -181,11 +211,15 @@ def print_bb_rewind_and_start_errors(self):
             for hostname, errors in self._rewind_errors.items():
                 for error in errors:
                     self._logger.info(bb_rewind_error_pattern.format(hostname, error.port, error.progress_file,
-                                                                     error.error_type))
+                                                                     error.error_type,
+                                                                     self.get_error_from_logfile(error.progress_file,
+                                                                                                 hostname)))
             for hostname, errors in self._bb_errors.items():
                 for error in errors:
                     self._logger.info(bb_rewind_error_pattern.format(hostname, error.port, error.progress_file,
-                                                                 error.error_type))
+                                                                 error.error_type,
+                                                                 self.get_error_from_logfile(error.progress_file,
+                                                                                             hostname)))
 
         start_error_pattern = " hostname: {}; port: {}; datadir: {}"
         if len(self._start_errors) > 0:
diff --git a/gpMgmt/bin/gppylib/test/unit/test_unit_gpcheckcat.py b/gpMgmt/bin/gppylib/test/unit/test_unit_gpcheckcat.py
index ccdfb03a7ad..e4ecdf616a0 100755
--- a/gpMgmt/bin/gppylib/test/unit/test_unit_gpcheckcat.py
+++ b/gpMgmt/bin/gppylib/test/unit/test_unit_gpcheckcat.py
@@ -411,6 +411,176 @@ def count_joins():
                 self.num_batches += 1
                 self.num_joins = 0
                 self.num_starts = 0
+
+    @patch('gpcheckcat.connect2')
+    def test_checkMixDistPolicy_with_error_on_execution(self,mock_connect2):
+        # Mocking the database connection to raise an exception during execution
+
+        mock_cursor = Mock()
+        mock_connect2.return_value.cursor.return_value.__enter__.return_value = mock_cursor
+        mock_cursor.execute.side_effect = Exception("Simulated error during execution")
+
+        # Call the function to test
+        self.subject.checkMixDistPolicy()
+
+        # Assertions
+        self.assertEqual(mock_cursor.execute.call_count, 1)
+        self.assertFalse(self.subject.GV.checkStatus)
+
+    @patch('gpcheckcat.connect2')
+    def test_checkMixDistPolicy_exception_on_connect(self, mock_connect2):
+        # Mocking the database connection to raise an exception during connection
+        mock_connect2.side_effect = Exception("Simulated error during connection")
+
+        # Call the function to test
+        self.subject.checkMixDistPolicy()
+
+        # Assertions
+        self.assertEqual(mock_connect2.call_count, 1)
+        self.assertFalse(self.subject.GV.checkStatus)
+
+    @patch('gpcheckcat.connect2')
+    def test_checkMixDistPolicy_exception_on_cursor_enter(self, mock_connect2):
+        # Mocking the database connection to raise an exception when entering the cursor context
+        mock_connect2.return_value.cursor.return_value.__enter__.side_effect = Exception("Simulated error entering cursor context")
+
+        # Call the function to test
+        self.subject.checkMixDistPolicy()
+
+        # Assertions
+        self.assertEqual(mock_connect2.call_count, 1)
+        self.assertFalse(self.subject.GV.checkStatus)
+
+    @patch('gpcheckcat.connect2')
+    def test_fetch_guc_value_with_error_on_execution(self,mock_connect2):
+        # Mocking the database connection to raise an exception during execution
+
+        mock_cursor = Mock()
+        mock_connect2.return_value.cursor.return_value.__enter__.return_value = mock_cursor
+        mock_cursor.execute.side_effect = Exception("Simulated error during execution")
+
+        # Call the function to test
+        self.subject.fetch_guc_value("gp_use_legacy_hashops")
+
+        # Assertions
+        self.assertEqual(mock_cursor.execute.call_count, 1)
+        self.assertEqual(mock_cursor.fetchone.call_count, 0)
+        self.subject.setError.assert_any_call(self.subject.ERROR_NOREPAIR)
+        self.assertFalse(self.subject.GV.checkStatus)
+
+    @patch('gpcheckcat.connect2')
+    def test_fetch_guc_value_exception_on_connect(self, mock_connect2):
+        # Mocking the database connection to raise an exception during connection
+        mock_cursor = Mock()
+        mock_connect2.return_value.cursor.return_value.__enter__.return_value = mock_cursor
+        mock_connect2.side_effect = Exception("Simulated error during execution")
+
+        # Call the function to test
+        self.subject.fetch_guc_value("gp_use_legacy_hashops")
+
+        # Assertions
+        self.assertEqual(mock_cursor.execute.call_count, 0)
+        self.assertEqual(mock_connect2.call_count, 1)
+        self.assertEqual(mock_cursor.fetchone.call_count, 0)
+        self.subject.setError.assert_any_call(self.subject.ERROR_NOREPAIR)
+        self.assertFalse(self.subject.GV.checkStatus)
+
+    @patch('gpcheckcat.connect2')
+    def test_fetch_guc_value_exception_on_cursor_enter(self, mock_connect2):
+        # Mocking the database connection to raise an exception on cursor context
+        mock_cursor = Mock()
+        #mock_connect2.return_value.cursor.return_value.__enter__.return_value = mock_cursor
+        mock_connect2.return_value.cursor.return_value = mock_cursor
+        mock_cursor.side_effect = Exception("Simulated error during execution")
+
+        # Call the function to test
+        self.subject.fetch_guc_value("gp_use_legacy_hashops")
+
+        # Assertions
+        self.assertEqual(mock_connect2.call_count, 1)
+        self.assertEqual(mock_cursor.execute.call_count, 0)
+        self.assertFalse(self.subject.GV.checkStatus)
+        self.assertEqual(mock_cursor.fetchone.call_count, 0)
+        self.subject.setError.assert_any_call(self.subject.ERROR_NOREPAIR)
+
+    def test_generateDistPolicyQueryFile(self):
+        # Call the function
+        self.subject.generateDistPolicyQueryFile()
+
+        # Check if the file is created
+        self.assertTrue(os.path.exists('gpcheckcat.distpolicy.sql'))
+
+        # Read the file and check if it contains the expected query
+        with open('gpcheckcat.distpolicy.sql', 'r') as fp:
+            generated_query = fp.read()
+
+        expected_query = '''
+     -- all tables that use legacy policy:
+     with legacy_opclass_oids(oid_array) as (
+       select
+         array_agg(oid)
+       from
+         pg_opclass
+       where
+         opcfamily in (
+           select
+             amprocfamily
+           from
+             pg_amproc
+           where
+             amproc :: oid in (
+               6140, 6141, 6142, 6143, 6144, 6145, 6146,
+               6147, 6148, 6149, 6150, 6151, 6152,
+               6153, 6154, 6155, 6156, 6157, 6158,
+               6159, 6160, 6161, 6162, 6163, 6164,
+               6165, 6166, 6167, 6168, 6170, 6169,
+               6171
+             )
+         )
+     )
+    select
+         localoid :: regclass :: text as "Legacy Policy"
+    from
+         gp_distribution_policy,
+         legacy_opclass_oids
+     where
+         policytype = 'p'
+         and distclass :: oid[] && oid_array;
+  
+ -- all tables that don't use any legacy policy:
+ with legacy_opclass_oids(oid_array) as (
+   select
+     array_agg(oid)
+   from
+     pg_opclass
+   where
+     opcfamily in (
+       select
+         amprocfamily
+       from
+         pg_amproc
+       where
+         amproc :: oid in (
+           6140, 6141, 6142, 6143, 6144, 6145, 6146,
+           6147, 6148, 6149, 6150, 6151, 6152,
+           6153, 6154, 6155, 6156, 6157, 6158,
+           6159, 6160, 6161, 6162, 6163, 6164,
+           6165, 6166, 6167, 6168, 6170, 6169,
+           6171
+         )
+     )
+ )
+select
+   localoid :: regclass :: text as "Non Legacy Policy"
+from
+   gp_distribution_policy,
+   legacy_opclass_oids
+where
+   policytype = 'p'
+   and not (distclass :: oid[] && oid_array);
+           '''
+        self.assertEqual.__self__.maxDiff = None
+        self.assertTrue(generated_query.strip() == expected_query.strip())
 class Global():
     def __init__(self):
         self.opt = {}
diff --git a/gpMgmt/bin/gppylib/test/unit/test_unit_gprecoverseg.py b/gpMgmt/bin/gppylib/test/unit/test_unit_gprecoverseg.py
index 292a6b8b5f1..1575661eddd 100644
--- a/gpMgmt/bin/gppylib/test/unit/test_unit_gprecoverseg.py
+++ b/gpMgmt/bin/gppylib/test/unit/test_unit_gprecoverseg.py
@@ -23,6 +23,8 @@ def __init__(self):
         self.recoveryConfigFile = None
         self.outputSpareDataDirectoryFile = None
         self.rebalanceSegments = None
+        self.disableReplayLag = None
+        self.replayLag = None
 
         self.outputSampleConfigFile = None
         self.parallelDegree = 1
@@ -32,6 +34,7 @@ def __init__(self):
         self.quiet = None
         self.interactive = False
         self.hba_hostnames = False
+        self.maxRate = None
 
 
 class GpRecoversegTestCase(GpTestCase):
@@ -88,6 +91,7 @@ def setUp(self):
             patch.object(GpMirrorListToBuild, "recover_mirrors"),
             patch.object(GpMirrorListToBuild, "getAdditionalWarnings"),
             patch.object(GpMirrorListToBuild, "getMirrorsToBuild"),
+            patch.object(GpMirrorListToBuild, "getMaxTransferRate"),
             patch.object(HeapChecksum, "check_segment_consistency"),
             patch.object(HeapChecksum, "get_segments_checksum_settings"),
         ])
diff --git a/gpMgmt/bin/gppylib/test/unit/test_unit_gpsegrecovery.py b/gpMgmt/bin/gppylib/test/unit/test_unit_gpsegrecovery.py
index 983b5f25a9a..93bb378bd1f 100644
--- a/gpMgmt/bin/gppylib/test/unit/test_unit_gpsegrecovery.py
+++ b/gpMgmt/bin/gppylib/test/unit/test_unit_gpsegrecovery.py
@@ -122,9 +122,10 @@ def setUp(self):
                                               p.getSegmentPort(),
                                               True, '/tmp/test_progress_file')
         self.era = '1234_20211110'
+        self.maxRate = '1024M'
         self.full_recovery_cmd = gpsegrecovery.FullRecovery(
             name='test full recovery', recovery_info=self.seg_recovery_info,
-            forceoverwrite=True, logger=self.mock_logger, era=self.era)
+            forceoverwrite=True, logger=self.mock_logger, era=self.era, maxRate=self.maxRate)
 
     def tearDown(self):
         super(FullRecoveryTestCase, self).tearDown()
@@ -154,9 +155,9 @@ def _assert_cmd_failed(self, expected_stderr):
     def test_basebackup_run_passes(self):
         self.full_recovery_cmd.run()
 
-        expected_init_args1 = call("/data/mirror0", "sdw1", '40000', create_slot=False,
+        expected_init_args1 = call("/data/mirror0", "sdw1", '40000', create_slot=True,
                                    replication_slot_name='internal_wal_replication_slot',
-                                   forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
+                                   forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file', max_rate='1024M')
 
         self._assert_basebackup_runs(expected_init_args1)
         self._assert_cmd_passed()
@@ -166,9 +167,9 @@ def test_basebackup_run_no_forceoverwrite_passes(self):
 
         self.full_recovery_cmd.run()
 
-        expected_init_args1 = call("/data/mirror0", "sdw1", '40000', create_slot=False,
+        expected_init_args1 = call("/data/mirror0", "sdw1", '40000', create_slot=True,
                                    replication_slot_name='internal_wal_replication_slot',
-                                   forceoverwrite=False, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
+                                   forceoverwrite=False, target_gp_dbid=2, progress_file='/tmp/test_progress_file', max_rate='1024M')
         self._assert_basebackup_runs(expected_init_args1)
         self._assert_cmd_passed()
 
@@ -177,70 +178,41 @@ def test_basebackup_run_one_exception(self):
 
         self.full_recovery_cmd.run()
 
-        expected_init_args1 = call("/data/mirror0", "sdw1", '40000', create_slot=False,
+        expected_init_args = call("/data/mirror0", "sdw1", '40000', create_slot=True,
                                    replication_slot_name='internal_wal_replication_slot',
-                                   forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
-        expected_init_args2 = call("/data/mirror0", "sdw1", '40000', create_slot=True,
-                                   replication_slot_name='internal_wal_replication_slot',
-                                   forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
-        self.assertEqual(2, self.mock_pgbasebackup_init.call_count)
-        self.assertEqual([expected_init_args1, expected_init_args2] , self.mock_pgbasebackup_init.call_args_list)
-        self.assertEqual(2, self.mock_pgbasebackup_run.call_count)
-        self.assertEqual([call(validateAfter=True),call(validateAfter=True)], self.mock_pgbasebackup_run.call_args_list)
-        gpsegrecovery.start_segment.assert_called_once_with(self.seg_recovery_info, self.mock_logger, self.era)
-        self._assert_cmd_passed()
-
-    def test_basebackup_run_two_exceptions(self):
-        self.mock_pgbasebackup_run.side_effect=[Exception('backup failed once'),
-                                                Exception('backup failed twice')]
-
-        self.full_recovery_cmd.run()
-
-        expected_init_args1 = call("/data/mirror0", "sdw1", '40000', create_slot=False,
-                                   replication_slot_name='internal_wal_replication_slot',
-                                   forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
-        expected_init_args2 = call("/data/mirror0", "sdw1", '40000', create_slot=True,
-                                   replication_slot_name='internal_wal_replication_slot',
-                                   forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
-        self.assertEqual(2, self.mock_pgbasebackup_init.call_count)
-        self.assertEqual([expected_init_args1, expected_init_args2], self.mock_pgbasebackup_init.call_args_list)
-        self.assertEqual(2, self.mock_pgbasebackup_run.call_count)
-        self.assertEqual([call(validateAfter=True),call(validateAfter=True)], self.mock_pgbasebackup_run.call_args_list)
-        self.mock_logger.info.any_call('Running pg_basebackup failed: backup failed once')
-        self.mock_logger.info.assert_called_with("Re-running pg_basebackup, creating the slot this time")
+                                   forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file', max_rate='1024M')
+        self.assertEqual(1, self.mock_pgbasebackup_init.call_count)
+        self.assertEqual([expected_init_args], self.mock_pgbasebackup_init.call_args_list)
+        self.assertEqual(1, self.mock_pgbasebackup_run.call_count)
+        self.assertEqual([call(validateAfter=True)], self.mock_pgbasebackup_run.call_args_list)
         self.assertEqual(0, gpsegrecovery.start_segment.call_count)
-        self._assert_cmd_failed('{"error_type": "full", "error_msg": "backup failed twice", "dbid": 2, ' \
+        self._assert_cmd_failed('{"error_type": "full", "error_msg": "backup failed once", "dbid": 2, ' \
                                 '"datadir": "/data/mirror0", "port": 50000, "progress_file": "/tmp/test_progress_file"}')
 
-    def test_basebackup_run_no_forceoverwrite_two_exceptions(self):
-        self.mock_pgbasebackup_run.side_effect = [Exception('backup failed once'),
-                                                  Exception('backup failed twice')]
-        self.full_recovery_cmd.forceoverwrite = False
+    def test_basebackup_run_no_forceoverwrite_one_exceptions(self):
+        self.mock_pgbasebackup_run.side_effect = [Exception('backup failed once'), Mock()]
 
+        self.full_recovery_cmd.forceoverwrite = False
         self.full_recovery_cmd.run()
 
-        expected_init_args1 = call("/data/mirror0", "sdw1", '40000', create_slot=False,
-                                   replication_slot_name='internal_wal_replication_slot',
-                                   forceoverwrite=False, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
-        # regardless of the passed in value, second call to pg_basebackup will always have forceoverwrite=True
-        expected_init_args2 = call("/data/mirror0", "sdw1", '40000', create_slot=True,
+        expected_init_args = call("/data/mirror0", "sdw1", '40000', create_slot=True,
                                    replication_slot_name='internal_wal_replication_slot',
-                                   forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
-        self.assertEqual(2, self.mock_pgbasebackup_init.call_count)
-        self.assertEqual([expected_init_args1, expected_init_args2], self.mock_pgbasebackup_init.call_args_list)
-        self.assertEqual(2, self.mock_pgbasebackup_run.call_count)
-        self.assertEqual([call(validateAfter=True),call(validateAfter=True)], self.mock_pgbasebackup_run.call_args_list)
+                                   forceoverwrite=False, target_gp_dbid=2, progress_file='/tmp/test_progress_file', max_rate='1024M')
+        self.assertEqual(1, self.mock_pgbasebackup_init.call_count)
+        self.assertEqual([expected_init_args], self.mock_pgbasebackup_init.call_args_list)
+        self.assertEqual(1, self.mock_pgbasebackup_run.call_count)
+        self.assertEqual([call(validateAfter=True)], self.mock_pgbasebackup_run.call_args_list)
         self.assertEqual(0, gpsegrecovery.start_segment.call_count)
-        self._assert_cmd_failed('{"error_type": "full", "error_msg": "backup failed twice", "dbid": 2, ' \
+        self._assert_cmd_failed('{"error_type": "full", "error_msg": "backup failed once", "dbid": 2, ' \
                                 '"datadir": "/data/mirror0", "port": 50000, "progress_file": "/tmp/test_progress_file"}')
 
     def test_basebackup_init_exception(self):
         self.mock_pgbasebackup_init.side_effect = [Exception('backup init failed')]
 
         self.full_recovery_cmd.run()
-        expected_init_args = call("/data/mirror0", "sdw1", '40000', create_slot=False,
+        expected_init_args = call("/data/mirror0", "sdw1", '40000', create_slot=True,
                                   replication_slot_name='internal_wal_replication_slot',
-                                  forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file')
+                                  forceoverwrite=True, target_gp_dbid=2, progress_file='/tmp/test_progress_file', max_rate='1024M')
         self.assertEqual(1, self.mock_pgbasebackup_init.call_count)
         self.assertEqual(expected_init_args, self.mock_pgbasebackup_init.call_args)
         self.assertEqual(0, self.mock_pgbasebackup_run.call_count)
@@ -273,6 +245,7 @@ def setUp(self):
         self.incr_r2 = RecoveryInfo('target_data_dir4', 5004, 4, 'source_hostname4',
                                     6004, False, '/tmp/progress_file4')
         self.era = '1234_2021110'
+        self.maxRate = '1024M'
 
         self.apply_patches([
             patch('gpsegrecovery.SegmentStart.__init__', return_value=None),
@@ -338,10 +311,10 @@ def test_complete_workflow_exception(self, mock_pgbasebackup_run, mock_pgbasebac
     def test_get_recovery_cmds_is_called(self, mock_get_recovery_cmds, mock_recovery_base_main, mock_logger):
         mix_confinfo = gppylib.recoveryinfo.serialize_list([self.full_r1, self.incr_r2])
         sys.argv = ['gpsegrecovery', '-l', '/tmp/logdir', '--era={}'.format(self.era), '-f',
-                    '-c {}'.format(mix_confinfo)]
+                    '-c {}'.format(mix_confinfo), '--max-rate={}'.format(self.maxRate)]
         SegRecovery().main()
         mock_get_recovery_cmds.assert_called_once_with([self.full_r1, self.incr_r2], True, mock_logger.return_value,
-                                                       self.era)
+                                                       self.era, self.maxRate)
         mock_recovery_base_main.assert_called_once_with(mock_get_recovery_cmds.return_value)
 
     def _assert_validation_full_call(self, cmd, expected_recovery_info,
@@ -363,26 +336,26 @@ def _assert_setup_incr_call(self, cmd, expected_recovery_info):
         self.assertEqual(self.mock_logger, cmd.logger)
 
     def test_empty_recovery_info_list(self):
-        cmd_list = SegRecovery().get_recovery_cmds([], False, None, self.era)
+        cmd_list = SegRecovery().get_recovery_cmds([], False, None, self.era, self.maxRate)
         self.assertEqual([], cmd_list)
 
     def test_get_recovery_cmds_full_recoveryinfo(self):
-        cmd_list = SegRecovery().get_recovery_cmds([self.full_r1, self.full_r2], False, self.mock_logger, self.era)
+        cmd_list = SegRecovery().get_recovery_cmds([self.full_r1, self.full_r2], False, self.mock_logger, self.era, self.maxRate)
         self._assert_validation_full_call(cmd_list[0], self.full_r1)
         self._assert_validation_full_call(cmd_list[1], self.full_r2)
 
     def test_get_recovery_cmds_incr_recoveryinfo(self):
-        cmd_list = SegRecovery().get_recovery_cmds([self.incr_r1, self.incr_r2], False, self.mock_logger, self.era)
+        cmd_list = SegRecovery().get_recovery_cmds([self.incr_r1, self.incr_r2], False, self.mock_logger, self.era, self.maxRate)
         self._assert_setup_incr_call(cmd_list[0], self.incr_r1)
         self._assert_setup_incr_call(cmd_list[1], self.incr_r2)
 
     def test_get_recovery_cmds_mix_recoveryinfo(self):
-        cmd_list = SegRecovery().get_recovery_cmds([self.full_r1, self.incr_r2], False, self.mock_logger, self.era)
+        cmd_list = SegRecovery().get_recovery_cmds([self.full_r1, self.incr_r2], False, self.mock_logger, self.era, self.maxRate)
         self._assert_validation_full_call(cmd_list[0], self.full_r1)
         self._assert_setup_incr_call(cmd_list[1], self.incr_r2)
 
     def test_get_recovery_cmds_mix_recoveryinfo_forceoverwrite(self):
-        cmd_list = SegRecovery().get_recovery_cmds([self.full_r1, self.incr_r2], True, self.mock_logger, self.era)
+        cmd_list = SegRecovery().get_recovery_cmds([self.full_r1, self.incr_r2], True, self.mock_logger, self.era, self.maxRate)
         self._assert_validation_full_call(cmd_list[0], self.full_r1,
                                           expected_forceoverwrite=True)
         self._assert_setup_incr_call(cmd_list[1], self.incr_r2)
diff --git a/gpMgmt/bin/gppylib/test/unit/test_unit_rebalance_segment.py b/gpMgmt/bin/gppylib/test/unit/test_unit_rebalance_segment.py
index 483bb1cb1a8..d9058757632 100644
--- a/gpMgmt/bin/gppylib/test/unit/test_unit_rebalance_segment.py
+++ b/gpMgmt/bin/gppylib/test/unit/test_unit_rebalance_segment.py
@@ -4,6 +4,7 @@
 from gppylib.gparray import GpArray, Segment
 from gppylib.commands.base import CommandResult
 from gppylib.operations.rebalanceSegments import GpSegmentRebalanceOperation
+from gppylib.operations.rebalanceSegments import replay_lag
 
 
 class RebalanceSegmentsTestCase(GpTestCase):
@@ -11,10 +12,20 @@ def setUp(self):
         self.pool = Mock()
         self.pool.getCompletedItems.return_value = []
 
+        mock_logger = Mock(spec=['log', 'warn', 'info', 'debug', 'error', 'warning', 'fatal'])
+
         self.apply_patches([
             patch("gppylib.commands.base.WorkerPool.__init__", return_value=None),
             patch("gppylib.commands.base.WorkerPool", return_value=self.pool),
             patch('gppylib.programs.clsRecoverSegment.GpRecoverSegmentProgram'),
+            patch('gppylib.operations.rebalanceSegments.logger', return_value=mock_logger),
+            patch('gppylib.db.dbconn.connect', autospec=True),
+            patch('gppylib.db.dbconn.querySingleton', return_value='5678'),
+            # Upstream only mocks dbconn.connect, which is enough there because
+            # its _trigger_fts_probe() goes through dbconn. Cloudberry's calls
+            # pg.connect() directly, so without this every test that lets
+            # rebalance() run to completion tries to open a real connection.
+            patch('gppylib.operations.segment_reconfigurer.pg.connect'),
         ])
 
         self.mock_gp_recover_segment_prog_class = self.get_mock_from_apply_patch('GpRecoverSegmentProgram')
@@ -32,8 +43,11 @@ def setUp(self):
         self.success_command_mock.get_results.return_value = CommandResult(
             0, b"stdout success text", b"stderr text", True, False)
 
-        self.subject = GpSegmentRebalanceOperation(Mock(), self._create_gparray_with_2_primary_2_mirrors(), 1, 1)
-        self.subject.logger = Mock()
+        self.subject = GpSegmentRebalanceOperation(Mock(), self._create_gparray_with_2_primary_2_mirrors(), 1, 1,
+                                                   False, 10)
+        self.subject.logger = Mock(spec=['log', 'warn', 'info', 'debug', 'error', 'warning', 'fatal'])
+
+        self.mock_logger = self.get_mock_from_apply_patch('logger')
 
     def tearDown(self):
         super(RebalanceSegmentsTestCase, self).tearDown()
@@ -58,6 +72,50 @@ def test_rebalance_returns_failure(self):
         result = self.subject.rebalance()
         self.assertFalse(result)
 
+    # cherry-pick from Greenplum Database
+    # greenplum-db/gpdb-archive @ 482967c1b4,
+    # gpMgmt/bin/gppylib/test/unit/test_unit_rebalance_segment.py
+    @patch('gppylib.db.dbconn.querySingleton', return_value='56780000000')
+    def test_rebalance_returns_warning(self, mock1):
+        with self.assertRaises(Exception) as ex:
+            self.subject.rebalance()
+        self.assertEqual('56780000000 bytes of wal is still to be replayed on mirror with dbid 2, let mirror catchup '
+                         'on replay then trigger rebalance. Use --replay-lag to configure the allowed replay lag limit '
+                         'or --disable-replay-lag to disable the check completely if you wish to continue with '
+                         'rebalance anyway', str(ex.exception))
+        self.assertEqual([call("Get replay lag on mirror of primary segment with host:sdw1, port:40000")],
+                         self.mock_logger.debug.call_args_list)
+        self.assertEqual([call("Determining primary and mirror segment pairs to rebalance"),
+                          call('Allowed replay lag during rebalance is 10 GB')],
+                         self.subject.logger.info.call_args_list)
+
+    @patch('gppylib.db.dbconn.querySingleton', return_value='5678000000')
+    def test_rebalance_does_not_return_warning(self, mock1):
+        self.subject.rebalance()
+        self.assertEqual([call("Get replay lag on mirror of primary segment with host:sdw1, port:40000")],
+                         self.mock_logger.debug.call_args_list)
+
+    @patch('gppylib.db.dbconn.querySingleton', return_value='56780000000')
+    def test_rebalance_replay_lag_is_disabled(self, mock1):
+        self.subject.disable_replay_lag = True
+        self.subject.rebalance()
+        self.assertNotIn([call("Get replay lag on mirror of primary segment with host:sdw1, port:40000")],
+                         self.mock_logger.debug.call_args_list)
+        self.assertIn([call("Determining primary and mirror segment pairs to rebalance")],
+                      self.subject.logger.info.call_args_list)
+
+    @patch('gppylib.db.dbconn.connect', side_effect=Exception())
+    def test_replay_lag_connect_exception(self, mock1):
+        with self.assertRaises(Exception) as ex:
+            replay_lag(self.primary0)
+        self.assertEqual('Failed to query pg_stat_replication for host:sdw1, port:40000, error: ', str(ex.exception))
+
+    @patch('gppylib.db.dbconn.querySingleton', side_effect=Exception())
+    def test_replay_lag_query_exception(self, mock1):
+        with self.assertRaises(Exception) as ex:
+            replay_lag(self.primary0)
+        self.assertEqual('Failed to query pg_stat_replication for host:sdw1, port:40000, error: ', str(ex.exception))
+
     def _create_gparray_with_2_primary_2_mirrors(self):
         coordinator = Segment.initFromString(
             "1|-1|p|p|s|u|cdw|cdw|5432|/data/coordinator")
diff --git a/gpMgmt/bin/gppylib/test/unit/test_unit_recovery_base.py b/gpMgmt/bin/gppylib/test/unit/test_unit_recovery_base.py
index 8d7f7c7a316..f5af9b6a439 100644
--- a/gpMgmt/bin/gppylib/test/unit/test_unit_recovery_base.py
+++ b/gpMgmt/bin/gppylib/test/unit/test_unit_recovery_base.py
@@ -324,7 +324,7 @@ def test_decorator(cmd):
             raise Exception('running the cmd failed')
 
         recovery_info = RecoveryInfo('/tmp/datadir2', 7002, 2, None, None, None, '/tmp/progress_file2')
-        test_cmd = FullRecovery('original name', recovery_info, True,None,None)
+        test_cmd = FullRecovery('original name', recovery_info, True,None,None,None)
         test_decorator(test_cmd)
         self.assertEqual('new name', test_cmd.name)
 
@@ -339,7 +339,7 @@ def test_decorator(cmd):
             cmd.error_type = None
             raise Exception('running the cmd failed')
         recovery_info = RecoveryInfo('/tmp/datadir2', 7002, 2, None, None, None, '/tmp/progress_file2')
-        test_cmd = FullRecovery('original name', recovery_info, True,None,None)
+        test_cmd = FullRecovery('original name', recovery_info, True,None,None,None)
         test_decorator(test_cmd)
         self.assertEqual('new name', test_cmd.name)
 
diff --git a/gpMgmt/bin/gppylib/test/unit/test_unit_recoveryinfo.py b/gpMgmt/bin/gppylib/test/unit/test_unit_recoveryinfo.py
index b744500a67b..d497ada68df 100644
--- a/gpMgmt/bin/gppylib/test/unit/test_unit_recoveryinfo.py
+++ b/gpMgmt/bin/gppylib/test/unit/test_unit_recoveryinfo.py
@@ -408,8 +408,8 @@ def run_tests(self, tests, run_recovery=False):
                 else:
                     host2_result = CommandResult(1, 'failed 2'.encode(), test["host2_error"].encode(), True, False)
 
-                host1_recovery_output = gp.GpSegRecovery(None, None, None, False, 1, 'host1', None, True)
-                host2_recovery_output = gp.GpSegRecovery(None, None, None, False, 1, 'host2', None, True)
+                host1_recovery_output = gp.GpSegRecovery(None, None, None, False, 1, 'host1', None, True, None)
+                host2_recovery_output = gp.GpSegRecovery(None, None, None, False, 1, 'host2', None, True, None)
                 host1_recovery_output.get_results = Mock(return_value=host1_result)
                 host2_recovery_output.get_results = Mock(return_value=host2_result)
 
diff --git a/gpMgmt/bin/gppylib/test/unit/test_unit_seg_update_pg_hba.py b/gpMgmt/bin/gppylib/test/unit/test_unit_seg_update_pg_hba.py
index 5ac6aee9249..5ddcbb17bd6 100644
--- a/gpMgmt/bin/gppylib/test/unit/test_unit_seg_update_pg_hba.py
+++ b/gpMgmt/bin/gppylib/test/unit/test_unit_seg_update_pg_hba.py
@@ -67,3 +67,87 @@ def test_remove_dup_with_spaces_add_entries(self):
         expected_out_entries = expected_block.\
             format(ip_mirror1='10.0.0.1', ip_mirror2='10.0.0.2', ip_mirror3='10.0.0.3').split('\n')
         self.assertEqual(result_out_entries, expected_out_entries)
+
+    def test_remove_stale_replication_entries(self):
+        existing_entries = """host replication gpadmin samehost trust
+host all gpadmin 10.0.0.1/32 trust
+host all gpadmin 10.0.0.2/32 trust
+host replication gpadmin 10.0.0.1/32 trust
+host replication gpadmin 10.0.0.2/32 trust""".split('\n')
+
+        input_entries = 'host replication gpadmin samehost trust\nhost all gpadmin 10.0.0.2/32 trust' \
+                        '\nhost replication gpadmin 10.0.0.2/32 trust\nhost replication gpadmin 10.0.0.3/32 trust'
+        unique_entries = seg_update_pg_hba.remove_dup_add_entries(existing_entries, input_entries)
+        result = seg_update_pg_hba.remove_stale_replication_entries(unique_entries, input_entries)
+
+        expected = """host replication gpadmin samehost trust
+host all gpadmin 10.0.0.1/32 trust
+host all gpadmin 10.0.0.2/32 trust
+host replication gpadmin 10.0.0.2/32 trust
+host replication gpadmin 10.0.0.3/32 trust""".split('\n')
+        self.assertEqual(result, expected)
+
+    def test_pg_hba_with_no_replication_entries(self):
+        existing_entries = """# standby coordinator host ip addresses
+host all gpadmin 10.0.0.2/32 trust
+host all gpadmin 10.0.0.1/32 trust""".split('\n')
+        input_entries = '# standby coordinator host ip addresses\nhost all gpadmin 10.0.0.2/32 trust'
+
+        result = seg_update_pg_hba.remove_stale_replication_entries(existing_entries, input_entries)
+
+        self.assertEqual(result, existing_entries)
+
+    def test_remove_stale_replication_entries_without_removing_localhost(self):
+        existing_entries = """# Allow replication connections from localhost, by a user with the
+# replication privilege.
+local   replication     all                                     trust
+host    replication     all             127.0.0.1/32            trust
+host    replication     all             ::1/128                 trust
+host replication gpadmin samehost trust
+host all gpadmin 10.0.0.1/32 trust
+host all gpadmin 10.0.0.2/32 trust
+host replication gpadmin 10.0.0.1/32 trust
+host replication gpadmin 10.0.0.2/32 trust""".split('\n')
+        input_entries = 'host replication gpadmin samehost trust\nhost all gpadmin 10.0.0.2/32 trust\nhost replication gpadmin 10.0.0.2/32 trust'
+
+        result = seg_update_pg_hba.remove_stale_replication_entries(existing_entries, input_entries)
+
+        expected = """# Allow replication connections from localhost, by a user with the
+# replication privilege.
+local   replication     all                                     trust
+host    replication     all             127.0.0.1/32            trust
+host    replication     all             ::1/128                 trust
+host replication gpadmin samehost trust
+host all gpadmin 10.0.0.1/32 trust
+host all gpadmin 10.0.0.2/32 trust
+host replication gpadmin 10.0.0.2/32 trust""".split('\n')
+
+        self.assertEqual(result, expected)
+
+    def test_remove_stale_replication_entries_without_removing_samehost(self):
+        existing_entries = """# Allow replication connections from localhost, by a user with the
+# replication privilege.
+local   replication     all                                     trust
+host    replication     all             127.0.0.1/32            trust
+host    replication     all             ::1/128                 trust
+host replication gpadmin samehost trust
+host all gpadmin 10.0.0.1/32 trust
+host all gpadmin 10.0.0.2/32 trust
+host replication gpadmin 10.0.0.1/32 trust
+host replication gpadmin 10.0.0.2/32 trust""".split('\n')
+        input_entries = 'host all gpadmin 10.0.0.2/32 trust\nhost replication gpadmin 10.0.0.2/32 trust'
+
+        result = seg_update_pg_hba.remove_stale_replication_entries(existing_entries, input_entries)
+
+        expected = """# Allow replication connections from localhost, by a user with the
+# replication privilege.
+local   replication     all                                     trust
+host    replication     all             127.0.0.1/32            trust
+host    replication     all             ::1/128                 trust
+host replication gpadmin samehost trust
+host all gpadmin 10.0.0.1/32 trust
+host all gpadmin 10.0.0.2/32 trust
+host replication gpadmin 10.0.0.2/32 trust""".split('\n')
+
+        self.assertEqual(result, expected)
+
diff --git a/gpMgmt/bin/gppylib/utils.py b/gpMgmt/bin/gppylib/utils.py
index 1adb1e68cdc..bc5af671fa5 100644
--- a/gpMgmt/bin/gppylib/utils.py
+++ b/gpMgmt/bin/gppylib/utils.py
@@ -505,7 +505,12 @@ def escapeDoubleQuoteInSQLString(string, forceDoubleQuote=True):
 
 
 def Escape(query_str):
-    return pgdb.escape_string(query_str)
+    # pgdb.escape_string() is a thin wrapper around libpq's PQescapeString,
+    # and the str overload encodes with the ASCII codec, so any non-ASCII
+    # identifier or value raises UnicodeEncodeError.  Hand it UTF-8 bytes
+    # instead: libpq escapes those byte-for-byte and the result decodes back
+    # to the original text.
+    return pgdb.escape_string(query_str.encode('utf-8')).decode('utf-8')
 
 
 def escapeArrayElement(query_str):
@@ -607,3 +612,45 @@ def formatInsertValuesList(row, starelid, inclHLL):
         rowVals.append('\t{0}::{1}'.format(val, typ))
 
     return rowVals
+
+
+def _resolve_all_addresses(name):
+    """
+    Every address a name resolves to, across address families.
+
+    Not gethostbyaddr(): it answers for one family only, so on a dual-stack
+    host "localhost" can come back as ::1 while an address that names the same
+    machine comes back as 127.0.0.1. Comparing those two lists says the names
+    are different hosts when they are not.
+    """
+    return {info[4][0] for info in socket.getaddrinfo(name, None)}
+
+
+# cherry-pick from Greenplum Database
+# greenplum-db/gpdb-archive @ 482967c1b4, gpMgmt/bin/gppylib/utils.py
+def validateHostnameAddress(hostname, address):
+    """
+    validateHostnameAddress : validates that given hostname and address are for the same host
+    Address can be hostname/alias also. Resolves hostname and address both to get the associated addresses.
+
+    @param hostname Name of the host to be validated
+    @param address Address of the host to be validated. Can be hostname/alias also
+    @return if the address and hostname are of the same host
+    """
+    try:
+        resolved_address_list = _resolve_all_addresses(hostname)
+        resolved_address_list_2 = _resolve_all_addresses(address)
+    except Exception as e:
+        # This means given hostname or address is not reachable
+        logger.warning(
+            "Could not resolve hostname:{0}."
+                .format(hostname))
+        return False
+
+    # Resolved address and hostname should have at least one IP address common if they are of same host
+    if not bool(resolved_address_list.intersection(resolved_address_list_2)):
+        logger.warning(
+            "Given address:{0} not present in resolved hostname:{1} address list we got:{2}".format(
+                address, hostname, sorted(resolved_address_list)))
+        return False
+    return True
diff --git a/gpMgmt/bin/gpstop b/gpMgmt/bin/gpstop
index ab7655597c9..e4123261f0e 100755
--- a/gpMgmt/bin/gpstop
+++ b/gpMgmt/bin/gpstop
@@ -983,5 +983,16 @@ class GpStop:
                       etcd_hosts=options.etcd_hosts,
                       is_external_fts=external_fts)
 
+    # Cherry-picked from Greenplum Database (greenplum-db/gpdb-archive @ 482967c1b4),
+    # gpMgmt/bin/gpstop; the docstring is reworded.
+    @staticmethod
+    def mainOptions():
+        """
+        This method returns a dictionary instructing simple_main to check for
+        a gpstop.lock file under COORDINATOR_DATA_DIRECTORY in order to prevent
+        more than one gpstop running against the same cluster at a time.
+        """
+        return {'pidlockpath': 'gpstop.lock', 'parentpidvar': 'GPSTOPPID'}
+
 if __name__ == '__main__':
-    simple_main(GpStop.createParser, GpStop.createProgram)
+    simple_main(GpStop.createParser, GpStop.createProgram, GpStop.mainOptions())
diff --git a/gpMgmt/bin/lib/gp_bash_functions.sh b/gpMgmt/bin/lib/gp_bash_functions.sh
index de76620da2b..45a12137815 100755
--- a/gpMgmt/bin/lib/gp_bash_functions.sh
+++ b/gpMgmt/bin/lib/gp_bash_functions.sh
@@ -231,6 +231,9 @@ LOG_MSG () {
 		*FATAL*)
 			EXIT_STATUS=1
 			;;
+		*ERROR*)
+			EXIT_STATUS=1
+			;;
 		esac
 
 		if [ x"" == x"$DEBUG_LEVEL" ];then
@@ -389,9 +392,9 @@ SED_PG_CONF () {
 				fi
 			else
 				if [ $KEEP_PREV -eq 0 ];then
-					$SED -i'.bak1' -e "s/${SEARCH_TXT}/${SUB_TXT} #${SEARCH_TXT}/" $FILENAME
+					$SED -i'.bak1' -e "s/^[ ]*${SEARCH_TXT}[ ]*=/${SUB_TXT} #${SEARCH_TXT}/" $FILENAME
 				else
-					$SED -i'.bak1' -e "s/${SEARCH_TXT}.*/${SUB_TXT}/" $FILENAME
+					$SED -i'.bak1' -e "s/^[ ]*${SEARCH_TXT}[ ]*=.*/${SUB_TXT}/" $FILENAME
 				fi
 				RETVAL=$?
 				if [ $RETVAL -ne 0 ]; then
@@ -400,7 +403,7 @@ SED_PG_CONF () {
 					LOG_MSG "[INFO]:-Replaced line in $FILENAME"
 					$RM -f ${FILENAME}.bak1
 				fi
-				$SED -i'.bak2' -e "s/^#${SEARCH_TXT}/${SEARCH_TXT}/" $FILENAME
+				$SED -i'.bak2' -e "s/^[ ]*#${SEARCH_TXT}[ ]*=/${SEARCH_TXT}=/" $FILENAME
 				RETVAL=$?
 				if [ $RETVAL -ne 0 ]; then
 					ERROR_EXIT "[FATAL]:-Failed to replace #$SEARCH_TXT in $FILENAME"
@@ -431,9 +434,9 @@ SED_PG_CONF () {
 			fi
 		else
 			if [ $KEEP_PREV -eq 0 ];then
-				SED_COMMAND="s/${SEARCH_TXT}/${SUB_TXT} #${SEARCH_TXT}/"
+				SED_COMMAND="s/^[ ]*${SEARCH_TXT}[ ]*=/${SUB_TXT} #${SEARCH_TXT}/"
 			else
-				SED_COMMAND="s/${SEARCH_TXT}.*/${SUB_TXT}/"
+				SED_COMMAND="s/^[ ]*${SEARCH_TXT}[ ]*=.*/${SUB_TXT}/"
 			fi
 			$TRUSTED_SHELL $SED_HOST sed -i'.bak1' -f /dev/stdin "$FILENAME" <<< "$SED_COMMAND" > /dev/null 2>&1
 			if [ $RETVAL -ne 0 ]; then
@@ -443,7 +446,7 @@ SED_PG_CONF () {
 				$TRUSTED_SHELL $SED_HOST "$RM -f ${FILENAME}.bak1" > /dev/null 2>&1
 			fi
 
-			SED_COMMAND="s/^#${SEARCH_TXT}/${SEARCH_TXT}/"
+			SED_COMMAND="s/^[ ]*#${SEARCH_TXT}[ ]*=/${SEARCH_TXT}=/"
 			$TRUSTED_SHELL $SED_HOST sed -i'.bak2' -f /dev/stdin "$FILENAME" <<< "$SED_COMMAND" > /dev/null 2>&1
 			if [ $RETVAL -ne 0 ]; then
 				ERROR_EXIT "[FATAL]:-Failed to substitute #${SEARCH_TXT} in $FILENAME on $SED_HOST"
@@ -783,6 +786,11 @@ BUILD_COORDINATOR_PG_HBA_FILE () {
         else
             $ECHO "host     all         $USER_NAME         localhost    trust" >> ${GP_DIR}/$PG_HBA
             $ECHO "host     all         $USER_NAME         $COORDINATOR_HOSTNAME       trust" >> ${GP_DIR}/$PG_HBA
+            # Also add explicit IPv4 and IPv6 loopback entries so that
+            # connections via 127.0.0.1 and ::1 are always accepted
+            # regardless of hostname resolution order.
+            $ECHO "host     all         $USER_NAME         127.0.0.1/32    trust" >> ${GP_DIR}/$PG_HBA
+            $ECHO "host     all         $USER_NAME         ::1/128         trust" >> ${GP_DIR}/$PG_HBA
         fi
 
 
@@ -1231,7 +1239,7 @@ PRECHECK_CBDB_CONFIG_FILE() {
 
 CLEANUP_ETCD() {
     if [ "$#" -ne 1 ];then
-        LOG_MSG "[ERROR]: RETRIVE_ETCD_CONFIG_VAL invalid params..."
+        LOG_MSG "[ERROR]: CLEANUP_ETCD invalid params..."
     fi
     local etcd_account_id=`RETRIVE_ETCD_CONFIG_VAL $ETCD_ACCOUNT_ID`
     local etcd_cluster_id=`RETRIVE_ETCD_CONFIG_VAL $ETCD_CLUSTER_ID`
@@ -1315,7 +1323,7 @@ SETUP_FTS() {
 
 CHECK_FTS () {
     ret=1
-    if [ "$#" -ne 2 ];then
+    if [ "$#" -ne 1 ];then
         LOG_MSG "[ERROR]: CHECK_FTS invalid params..."
     fi
     FTS_HOST=$1
diff --git a/gpMgmt/bin/lib/gpconfigurenewsegment b/gpMgmt/bin/lib/gpconfigurenewsegment
index c37c70bf1fa..26a6c4d96b7 100755
--- a/gpMgmt/bin/lib/gpconfigurenewsegment
+++ b/gpMgmt/bin/lib/gpconfigurenewsegment
@@ -134,45 +134,31 @@ class ConfExpSegCmd(Command):
                         self.progressFile = '%s/pg_basebackup.%s.dbid%s.out' % (gplog.get_logger_dir(),
                                                                                 datetime.datetime.today().strftime('%Y%m%d_%H%M%S'),
                                                                                 self.dbid)
-                    # Create a mirror based on the primary
-                    cmd = PgBaseBackup(target_datadir=self.datadir,
-                                       source_host=self.syncWithSegmentHostname,
-                                       source_port=str(self.syncWithSegmentPort),
-                                       create_slot = False,
-                                       replication_slot_name=self.replicationSlotName,
-                                       forceoverwrite=self.forceoverwrite,
-                                       target_gp_dbid=self.dbid,
-                                       logfile=self.progressFile)
+                    # Create a mirror based on the primary.
+                    #
+                    # Built inside the try: PgBaseBackup's constructor now asks
+                    # the source segment whether the replication slot exists, so
+                    # it can fail, and a failure out here would leave the command
+                    # with no result at all -- the pool then reports
+                    # "'NoneType' object has no attribute 'wasSuccessful'"
+                    # instead of saying what went wrong.
                     try:
+                        cmd = PgBaseBackup(target_datadir=self.datadir,
+                                           source_host=self.syncWithSegmentHostname,
+                                           source_port=str(self.syncWithSegmentPort),
+                                           create_slot=True,
+                                           replication_slot_name=self.replicationSlotName,
+                                           forceoverwrite=self.forceoverwrite,
+                                           target_gp_dbid=self.dbid,
+                                           progress_file=self.progressFile)
                         logger.info("Running pg_basebackup with progress output temporarily in %s" % self.progressFile)
                         cmd.run(validateAfter=True)
                         self.set_results(CommandResult(0, b'', b'', True, False))
                         if shouldDeleteProgressFile:
                             os.remove(self.progressFile)
-
                     except Exception as e:
-                        #  If the cluster never has mirrors, cmd will fail
-                        #  quickly because the internal slot doesn't exist.
-                        #  Re-run with `create_slot`.
-                        #  GPDB_12_MERGE_FIXME could we check it before? or let
-                        #  pg_basebackup create slot if not exists.
-                        cmd = PgBaseBackup(target_datadir=self.datadir,
-                                           source_host=self.syncWithSegmentHostname,
-                                           source_port=str(self.syncWithSegmentPort),
-                                           create_slot = True,
-                                           replication_slot_name=self.replicationSlotName,
-                                           forceoverwrite=True,
-                                           target_gp_dbid=self.dbid,
-                                           logfile=self.progressFile)
-                        try:
-                            logger.info("Re-running pg_basebackup, creating the slot this time")
-                            cmd.run(validateAfter=True)
-                            self.set_results(CommandResult(0, b'', b'', True, False))
-                            if shouldDeleteProgressFile:
-                                os.remove(self.progressFile)
-                        except Exception as e:
-                            self.set_results(CommandResult(1, b'', str(e).encode(), True, False))
-                            raise
+                        self.set_results(CommandResult(1, b'', str(e).encode(), True, False))
+                        raise
 
                     logger.info("Successfully ran pg_basebackup: %s" % cmd.cmdStr)
                     return
diff --git a/gpMgmt/bin/lib/gpcreateseg.sh b/gpMgmt/bin/lib/gpcreateseg.sh
index 5dd0f5b0006..78883f9463d 100755
--- a/gpMgmt/bin/lib/gpcreateseg.sh
+++ b/gpMgmt/bin/lib/gpcreateseg.sh
@@ -224,6 +224,20 @@ CREATE_QES_MIRROR () {
     fi
     RUN_COMMAND_REMOTE ${PRIMARY_HOSTADDRESS} "${EXPORT_GPHOME}; . ${GPHOME}/cloudberry-env.sh; cat - >> ${PRIMARY_DIR}/pg_hba.conf; pg_ctl -D ${PRIMARY_DIR} reload" <<< "${PG_HBA_ENTRIES}"
     RUN_COMMAND_REMOTE ${GP_HOSTADDRESS} "${EXPORT_GPHOME}; . ${GPHOME}/cloudberry-env.sh; rm -rf ${GP_DIR}; ${GPHOME}/bin/pg_basebackup --wal-method=stream --create-slot --slot='internal_wal_replication_slot' -R -c fast -E ./db_dumps -D ${GP_DIR} -h ${PRIMARY_HOSTADDRESS} -p ${PRIMARY_PORT} --target-gp-dbid ${GP_DBID};"
+    # pg_basebackup copies the primary's postgresql.conf verbatim, so the
+    # mirror would otherwise start on the primary's port. Append the right
+    # one before starting; the last setting in the file wins.
+    #
+    # $PORT_TXT ("#port") finds nothing in the copied file -- the port line is
+    # already active there -- so SED_PG_CONF takes its append path. That is
+    # what we want: its replace path runs an unanchored
+    # "s/<search>/<sub> #<search>/", which with a search string of "port"
+    # would also rewrite every "support", "report" and "transport" in the
+    # file's comments.
+    LOG_MSG "[INFO][$INST_COUNT]:-Configuring segment $PG_CONF"
+    SED_PG_CONF ${GP_DIR}/$PG_CONF "$PORT_TXT" port=$GP_PORT 0 $GP_HOSTADDRESS
+    RETVAL=$?
+    PARA_EXIT $RETVAL "Update port number to $GP_PORT"
     START_QE "-w"
     RETVAL=$?
     PARA_EXIT $RETVAL "pg_basebackup of segment data directory from ${PRIMARY_HOSTADDRESS} to ${GP_HOSTADDRESS}"
diff --git a/gpMgmt/bin/minirepro b/gpMgmt/bin/minirepro
index 79d4c9fbb31..9a93389b14c 100755
--- a/gpMgmt/bin/minirepro
+++ b/gpMgmt/bin/minirepro
@@ -74,6 +74,11 @@ sysnslist = "('pg_toast', 'pg_bitmapindex', 'pg_catalog', 'information_schema',
 # unset search path due to CVE-2018-1058
 pgoptions = '-c optimizer=off -c gp_role=utility -c search_path='
 
+
+def escape_sql_literal(value):
+    return value.replace("'", "''")
+
+
 class MRQuery(object):
     def __init__(self):
         self.schemas = []
@@ -136,7 +141,7 @@ def dump_query(connectionInfo, query_file):
 
     with open(query_file, 'r') as query_f:
         sql_text = query_f.read()
-    query = "select pg_catalog.gp_dump_query_oids('%s')" % Escape(sql_text)
+    query = "select pg_catalog.gp_dump_query_oids('%s')" % escape_sql_literal(sql_text)
 
     toolkit_sql = PATH_PREFIX + 'toolkit.sql'
     with open(toolkit_sql, 'w') as toolkit_f:
@@ -165,6 +170,27 @@ def parse_oids(cursor, json_oids):
     if len(result.funcids) == 0:
         result.funcids = '0'
 
+    # In PG16, gp_dump_query_oids may return only view OIDs without their
+    # dependent table OIDs. Expand view dependencies so pg_dump includes
+    # the tables that views reference.
+    dep_query = "SELECT DISTINCT d.refobjid FROM pg_depend d " \
+                "JOIN pg_class c ON d.classid = 'pg_rewrite'::regclass " \
+                "JOIN pg_rewrite r ON d.objid = r.oid " \
+                "WHERE r.ev_class IN (%s) AND d.refobjid != r.ev_class " \
+                "AND d.refclassid = 'pg_class'::regclass " \
+                "AND d.refobjid NOT IN (%s)" % (result.relids, result.relids)
+    try:
+        cursor.execute(dep_query)
+        dep_oids = [str(row[0]) for row in result_iter(cursor)]
+        if dep_oids:
+            result.relids = result.relids + ',' + ','.join(dep_oids)
+    except pgdb.DatabaseError as e:
+        # The dump is still usable without the view's base tables, so warn
+        # and carry on with the OIDs gp_dump_query_oids gave us.
+        sys.stderr.write('\nWarning: could not expand view dependencies; '
+                         'the dump may be missing tables referenced by views.\n\n'
+                         + str(e) + '\n\n')
+
     cat_query = "SELECT distinct(nspname) FROM pg_class c, pg_namespace n WHERE " \
                 "c.relnamespace = n.oid AND c.oid IN (%s) " \
                 "AND n.nspname NOT IN %s" % (result.relids, sysnslist)
diff --git a/gpMgmt/sbin/gpsegrecovery.py b/gpMgmt/sbin/gpsegrecovery.py
index 811a73ccbb5..5b0834eedac 100644
--- a/gpMgmt/sbin/gpsegrecovery.py
+++ b/gpMgmt/sbin/gpsegrecovery.py
@@ -7,18 +7,19 @@
 from gppylib.commands.pg import PgBaseBackup, PgRewind
 from recovery_base import RecoveryBase, set_recovery_cmd_results
 from gppylib.commands.base import Command
-from gppylib.commands.gp import SegmentStart
+from gppylib.commands.gp import SegmentStart, ModifyConfSetting
 from gppylib.gparray import Segment
 from gppylib.commands.unix import terminate_proc_tree
 
 
 class FullRecovery(Command):
-    def __init__(self, name, recovery_info, forceoverwrite, logger, era):
+    def __init__(self, name, recovery_info, forceoverwrite, logger, era, maxRate):
         self.name = name
         self.recovery_info = recovery_info
         self.replicationSlotName = 'internal_wal_replication_slot'
         self.forceoverwrite = forceoverwrite
         self.era = era
+        self.maxRate = maxRate
         # FIXME test for this cmdstr. also what should this cmdstr be ?
         cmdStr = ''
         #cmdstr = 'TODO? : {} {}'.format(str(recovery_info), self.verbose)
@@ -33,36 +34,22 @@ def run(self):
         cmd = PgBaseBackup(self.recovery_info.target_datadir,
                            self.recovery_info.source_hostname,
                            str(self.recovery_info.source_port),
-                           create_slot=False,
+                           create_slot=True,
                            replication_slot_name=self.replicationSlotName,
                            forceoverwrite=self.forceoverwrite,
                            target_gp_dbid=self.recovery_info.target_segment_dbid,
-                           progress_file=self.recovery_info.progress_file)
+                           progress_file=self.recovery_info.progress_file,
+                           max_rate=self.maxRate)
         self.logger.info("Running pg_basebackup with progress output temporarily in %s" % self.recovery_info.progress_file)
-        try:
-            cmd.run(validateAfter=True)
-        except Exception as e: #TODO should this be ExecutionError?
-            self.logger.info("Running pg_basebackup failed: {}".format(str(e)))
-
-            #  If the cluster never has mirrors, cmd will fail
-            #  quickly because the internal slot doesn't exist.
-            #  Re-run with `create_slot`.
-            #  GPDB_12_MERGE_FIXME could we check it before? or let
-            #  pg_basebackup create slot if not exists.
-            cmd = PgBaseBackup(self.recovery_info.target_datadir,
-                               self.recovery_info.source_hostname,
-                               str(self.recovery_info.source_port),
-                               create_slot=True,
-                               replication_slot_name=self.replicationSlotName,
-                               forceoverwrite=True,
-                               target_gp_dbid=self.recovery_info.target_segment_dbid,
-                               progress_file=self.recovery_info.progress_file)
-            self.logger.info("Re-running pg_basebackup, creating the slot this time")
-            cmd.run(validateAfter=True)
+        cmd.run(validateAfter=True)
 
         self.error_type = RecoveryErrorType.DEFAULT_ERROR
         self.logger.info("Successfully ran pg_basebackup for dbid: {}".format(
             self.recovery_info.target_segment_dbid))
+
+        # Updating port number on conf after recovery
+        update_port_in_conf(self.recovery_info, self.logger)
+
         self.error_type = RecoveryErrorType.START_ERROR
         start_segment(self.recovery_info, self.logger, self.era)
 
@@ -87,10 +74,27 @@ def run(self):
         cmd.run(validateAfter=True)
         self.logger.info("Successfully ran pg_rewind for dbid: {}".format(self.recovery_info.target_segment_dbid))
 
+        # Updating port number on conf after recovery
+        update_port_in_conf(self.recovery_info, self.logger)
+
         self.error_type = RecoveryErrorType.START_ERROR
         start_segment(self.recovery_info, self.logger, self.era)
 
 
+def update_port_in_conf(recovery_info, logger):
+    """
+    pg_basebackup and pg_rewind both copy the source segment's
+    postgresql.conf, which carries the *source* port. Point it back at this
+    segment before it is started, or the mirror comes up on its primary's
+    port.
+    """
+    logger.info("Updating %s/postgresql.conf" % recovery_info.target_datadir)
+    modifyConfCmd = ModifyConfSetting('Updating %s/postgresql.conf' % recovery_info.target_datadir,
+                                      "{}/{}".format(recovery_info.target_datadir, 'postgresql.conf'),
+                                      'port', recovery_info.target_port, optType='number')
+    modifyConfCmd.run(validateAfter=True)
+
+
 def start_segment(recovery_info, logger, era):
     seg = Segment(None, None, None, None, None, None, None, None,
                   recovery_info.target_port, recovery_info.target_datadir)
@@ -124,9 +128,10 @@ def signal_handler(sig, frame):
         signal.signal(signal.SIGTERM, signal_handler)
 
         recovery_base.main(self.get_recovery_cmds(recovery_base.seg_recovery_info_list, recovery_base.options.forceoverwrite,
-                                                  recovery_base.logger, recovery_base.options.era))
+                                                  recovery_base.logger, recovery_base.options.era,
+                                                  recovery_base.options.maxRate))
 
-    def get_recovery_cmds(self, seg_recovery_info_list, forceoverwrite, logger, era):
+    def get_recovery_cmds(self, seg_recovery_info_list, forceoverwrite, logger, era, maxRate):
         cmd_list = []
         for seg_recovery_info in seg_recovery_info_list:
             if seg_recovery_info.is_full_recovery:
@@ -134,7 +139,8 @@ def get_recovery_cmds(self, seg_recovery_info_list, forceoverwrite, logger, era)
                                    recovery_info=seg_recovery_info,
                                    forceoverwrite=forceoverwrite,
                                    logger=logger,
-                                   era=era)
+                                   era=era,
+                                   maxRate=maxRate)
             else:
                 cmd = IncrementalRecovery(name='Run pg_rewind',
                                           recovery_info=seg_recovery_info,
diff --git a/gpMgmt/sbin/recovery_base.py b/gpMgmt/sbin/recovery_base.py
index 36bbb0d13ba..0a6e76b34e8 100644
--- a/gpMgmt/sbin/recovery_base.py
+++ b/gpMgmt/sbin/recovery_base.py
@@ -39,6 +39,7 @@ def parseargs(self):
         parser.add_option('-f', '--force-overwrite', dest='forceoverwrite', action='store_true', default=False)
         parser.add_option('-l', '--log-dir', dest="logfileDirectory", type="string")
         parser.add_option('', '--era', dest="era", help="coordinator era", )
+        parser.add_option('--max-rate', type='string', dest='maxRate', metavar='<maxRate>')
 
         # Parse the command line arguments
         self.options, _ = parser.parse_args()
diff --git a/gpMgmt/sbin/seg_update_pg_hba.py b/gpMgmt/sbin/seg_update_pg_hba.py
index 8e8b4c800f2..6e076e52bcc 100755
--- a/gpMgmt/sbin/seg_update_pg_hba.py
+++ b/gpMgmt/sbin/seg_update_pg_hba.py
@@ -72,6 +72,36 @@ def remove_dup_add_entries(lines, entries):
 
     return out_entries
 
+# remove_stale_replication_entries() and is_stale_replication_entry() are
+# cherry-picked unmodified from Greenplum Database (greenplum-db/gpdb-archive @ 482967c1b4),
+# gpMgmt/sbin/seg_update_pg_hba.py.
+def remove_stale_replication_entries(existing_hba, entries):
+    final_entries = []
+    replication_entry = "replication" in entries
+
+    for line in existing_hba:
+        if line not in entries.split('\n'):
+            # check for stale replication entries on existing pg_hba.conf
+            if replication_entry and is_stale_replication_entry(line):
+                continue
+        final_entries.append(line.strip())
+
+    return final_entries
+
+def is_stale_replication_entry(line):
+    # Here considering all non-local replication entries as stale.
+    # This assumes 1:1 replication and will not work with 1:N replication.
+
+    localhost_entries = ["127.0.0.1/32", "::1/128", "local", "samehost"]
+    # return False if line is a comment or not a replication entry
+    if line.startswith('#') or "replication" not in line:
+        return False
+    # keep replication entries present for localhost
+    if any(entry in line for entry in localhost_entries):
+        return False
+
+    return True
+
 def run_pg_ctl_reload(datadir):
     name = "pg_ctl reload"
     cmd_str = "$GPHOME/bin/pg_ctl reload -D %s" % datadir
@@ -83,7 +113,8 @@ def main():
     hba_filename = options.datadir +'/pg_hba.conf'
     lines, temp_hba_filename = read_from_hba_file_and_get_empty_tempfile(hba_filename)
     out_entries = remove_dup_add_entries(lines, options.entries)
-    write_entries(out_entries, temp_hba_filename, hba_filename)
+    final_entries = remove_stale_replication_entries(out_entries, options.entries)
+    write_entries(final_entries, temp_hba_filename, hba_filename)
     run_pg_ctl_reload(options.datadir)
 
 if __name__ == "__main__":
diff --git a/gpMgmt/test/README b/gpMgmt/test/README
index bcea2a0cd98..286100b2dd2 100644
--- a/gpMgmt/test/README
+++ b/gpMgmt/test/README
@@ -60,3 +60,37 @@ From behave documentation (behave is now installed via pip):
 | you have to use logical AND::
 | 
 |     --tags ~@fixme --tags ~@buggy.
+
+---------------------------ORIGIN OF THIS SUITE------------------------
+
+These tests come from Greenplum Database and are kept aligned with it, so
+that a fix made upstream can be compared against ours file by file. Every
+file under test/behave/ has the same path in
+
+    greenplum-db/gpdb-archive @ 482967c1b4
+
+Where a block was taken from Greenplum into product code rather than into
+the suite, the source is named in a comment at that block.
+
+Cloudberry does not implement everything the Greenplum suite covers, and
+some scenarios describe a cluster this project does not run in CI. Rather
+than delete them -- which loses the coverage the day the feature arrives --
+they carry a tag, and the CI matrix filters on it:
+
+    @concourse_cluster  needs more than one host. Greenplum runs these on a
+                        fresh multi-host cluster per job; CI here builds a
+                        single-host demo cluster, so they are filtered out.
+    @demo_cluster       runs against the demo cluster CI builds.
+    @not_implemented    the behaviour was never built in Cloudberry. No
+                        scenario carries this today -- the suite's remaining
+                        gaps were ported from Greenplum -- but the CI matrix
+                        still filters on it, so it is the tag to reach for if
+                        an imported scenario ever outruns the product again.
+    @differential       needs gprecoverseg --differential, which Cloudberry
+                        does not have.
+    @extended           long-running; not part of the per-commit matrix.
+    @requires_netem     needs the netem kernel module to shape traffic.
+
+A scenario carrying @concourse_cluster is excluded by --tags ~@concourse_cluster
+whatever else it carries, so a scenario tagged both @concourse_cluster and
+@demo_cluster does not run in CI.
diff --git a/gpMgmt/test/behave/mgmt_utils/environment.py b/gpMgmt/test/behave/mgmt_utils/environment.py
index d79f9c18acc..1017544fe00 100644
--- a/gpMgmt/test/behave/mgmt_utils/environment.py
+++ b/gpMgmt/test/behave/mgmt_utils/environment.py
@@ -1,5 +1,7 @@
 import os
+import re
 import shutil
+from contextlib import closing
 
 import behave
 
@@ -11,6 +13,7 @@
 from steps.gpssh_exkeys_mgmt_utils import GpsshExkeysMgmtContext
 from steps.mgmt_utils import backup_bashrc, restore_bashrc
 from gppylib.db import dbconn
+from gppylib.commands.base import Command, REMOTE
 
 def before_all(context):
     if list(map(int, behave.__version__.split('.'))) < [1,2,6]:
@@ -62,19 +65,27 @@ def before_feature(context, feature):
         dbconn.execSQL(context.conn, 'create table t1(a integer, b integer)')
         dbconn.execSQL(context.conn, 'create table t2(c integer, d integer)')
         dbconn.execSQL(context.conn, 'create table t3(e integer, f integer)')
+        dbconn.execSQL(context.conn, 'create table spiegelungssätze(col_ä integer, 列2 integer)')
         dbconn.execSQL(context.conn, 'create view v1 as select a, b from t1, t3 where t1.a=t3.e')
         dbconn.execSQL(context.conn, 'create view v2 as select c, d from t2, t3 where t2.c=t3.f')
         dbconn.execSQL(context.conn, 'create view v3 as select a, d from v1, v2 where v1.a=v2.c')
         dbconn.execSQL(context.conn, 'insert into t1 values(1, 2)')
         dbconn.execSQL(context.conn, 'insert into t2 values(1, 3)')
         dbconn.execSQL(context.conn, 'insert into t3 values(1, 4)')
+        dbconn.execSQL(context.conn, 'insert into spiegelungssätze values(1, 5)')
+        # minirepro tests require statistical data about the contents of the database
+        # we should execute 'ANALYZE' to fill the pg_statistic catalog table.
+        dbconn.execSQL(context.conn, 'analyze t1')
+        dbconn.execSQL(context.conn, 'analyze t2')
+        dbconn.execSQL(context.conn, 'analyze t3')
+        dbconn.execSQL(context.conn, 'analyze spiegelungssätze')
+        dbconn.execSQL(context.conn, 'create or replace function select_one() returns integer as $$ select 1 $$ language sql')
         context.conn.commit()
 
     if 'gppkg' in feature.tags:
         run_command(context, 'bash demo/gppkg/generate_sample_gppkg.sh buildGppkg')
         run_command(context, 'cp -f /tmp/sample-gppkg/sample.gppkg test/behave/mgmt_utils/steps/data/')
 
-
 def after_feature(context, feature):
     if 'analyzedb' in feature.tags:
         context.conn.close()
@@ -102,6 +113,9 @@ def before_scenario(context, scenario):
     if 'gprecoverseg' in context.feature.tags:
         context.mirror_context = MirrorMgmtContext()
 
+    if 'gprecoverseg_newhost' in context.feature.tags:
+        context.mirror_context = MirrorMgmtContext()
+
     if 'gpconfig' in context.feature.tags:
         context.gpconfig_context = GpConfigContext()
 
@@ -119,12 +133,58 @@ def before_scenario(context, scenario):
     if 'gp_bash_functions.sh' in context.feature.tags or 'backup_restore_bashrc' in scenario.effective_tags:
         backup_bashrc()
 
+def preserve_logs_for_failed_scenario(scenario):
+    """
+    Snapshot gpAdminLogs and every segment's postgresql.conf while they still
+    describe the failure. Scenarios routinely start by emptying gpAdminLogs, so
+    by the end of a feature the logs of the scenario that failed are long gone
+    and the CI artifact is useless for diagnosis.
+    """
+    # Behave runs from gpMgmt/; build-logs/ lives at the top of the source tree,
+    # which is what the CI job uploads.
+    src_dir = os.environ.get('SRC_DIR') or os.path.dirname(os.getcwd())
+    dest_root = os.path.join(src_dir, 'build-logs', 'failed-scenarios')
+    name = re.sub(r'[^A-Za-z0-9._-]+', '_', scenario.name)[:80]
+    dest = os.path.join(dest_root, '%s.%s' % (scenario.line, name))
+    try:
+        os.makedirs(dest, exist_ok=True)
+        admin_logs = os.path.join(os.path.expanduser('~'), 'gpAdminLogs')
+        if os.path.isdir(admin_logs):
+            log_dest = os.path.join(dest, 'gpAdminLogs')
+            os.makedirs(log_dest, exist_ok=True)
+            for entry in os.listdir(admin_logs):
+                path = os.path.join(admin_logs, entry)
+                if not os.path.isfile(path):
+                    continue
+                # Some of these are named gpsegstop.py_cdw:gpadmin_<date>.log,
+                # and upload-artifact refuses any path containing a colon.
+                shutil.copyfile(path, os.path.join(log_dest, entry.replace(':', '_')))
+        with closing(dbconn.connect(dbconn.DbURL(dbname='postgres'), unsetSearchPath=False)) as conn:
+            rows = dbconn.query(conn, "SELECT dbid, content, role, port, datadir "
+                                      "FROM gp_segment_configuration ORDER BY dbid").fetchall()
+        with open(os.path.join(dest, 'segment_configuration.txt'), 'w') as fh:
+            for row in rows:
+                fh.write('|'.join(str(c) for c in row) + '\n')
+        for dbid, _content, _role, _port, datadir in rows:
+            conf = os.path.join(datadir, 'postgresql.conf')
+            if os.path.isfile(conf):
+                shutil.copyfile(conf, os.path.join(dest, 'postgresql.conf.dbid%s' % dbid))
+    except Exception as e:
+        # Never let diagnostics turn a failure into a different failure.
+        print('could not preserve logs for %s: %s' % (scenario.name, e))
+
+
 def after_scenario(context, scenario):
     #TODO: you'd think that the scenario.skip() in before_scenario() would
     #  cause this to not be needed
     if "skip" in scenario.effective_tags:
         return
 
+    # behave hands back a Status enum here; compare on its name so this works
+    # whatever behave version is installed, and never let it raise.
+    if str(getattr(scenario, 'status', '')).split('.')[-1] == 'failed':
+        preserve_logs_for_failed_scenario(scenario)
+
     if 'tablespaces' in context:
         for tablespace in list(context.tablespaces.values()):
             tablespace.cleanup()
@@ -146,11 +206,17 @@ def after_scenario(context, scenario):
         return
 
     tags_to_cleanup = ['gpmovemirrors', 'gpssh-exkeys']
-    if set(context.feature.tags).intersection(tags_to_cleanup):
+    if set(context.feature.tags).intersection(tags_to_cleanup) and "skip_cleanup" not in scenario.effective_tags:
         if 'temp_base_dir' in context and os.path.exists(context.temp_base_dir):
             os.chmod(context.temp_base_dir, 0o700)
             shutil.rmtree(context.temp_base_dir)
 
+        if 'umount_required' in context and context.umount_required:
+            context.execute_steps('''
+                        # unmounting all mounter filesystem in concourse cluster
+                        Then umount all mounted filesystem
+                        ''')
+
     tags_to_not_restart_db = ['analyzedb', 'gpssh-exkeys']
     if not set(context.feature.tags).intersection(tags_to_not_restart_db):
         start_database_if_not_started(context)
@@ -182,3 +248,12 @@ def after_scenario(context, scenario):
         execute_sql('postgres', create_fault_query)
         reset_fault_query = "SELECT gp_inject_fault_infinite('all', 'reset', dbid) FROM gp_segment_configuration WHERE status='u';"
         execute_sql('postgres', reset_fault_query)
+
+    if os.getenv('SUSPEND_PG_REWIND') is not None:
+        del os.environ['SUSPEND_PG_REWIND']
+
+    if "remove_rsync_bash" in scenario.effective_tags:
+        for host in context.hosts_with_rsync_bash:
+            cmd = Command(name='remove /usr/local/bin/rsync', cmdStr="sudo rm /usr/local/bin/rsync", remoteHost=host,
+                          ctxt=REMOTE)
+            cmd.run(validateAfter=True)
diff --git a/gpMgmt/test/behave/mgmt_utils/gpaddmirrors.feature b/gpMgmt/test/behave/mgmt_utils/gpaddmirrors.feature
index e65e782938d..9817183b579 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpaddmirrors.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpaddmirrors.feature
@@ -5,6 +5,8 @@ Feature: Tests for gpaddmirrors
           And a tablespace is created with data
          When gpaddmirrors adds 3 mirrors
           And an FTS probe is triggered
+          #gpaddmirrors triggers full recovery where old replication slot is dropped and new one is created
+          And verify replication slot internal_wal_replication_slot is available on all the segments
           And the segments are synchronized
          Then verify the database has mirrors
           And the tablespace is valid
@@ -24,6 +26,8 @@ Feature: Tests for gpaddmirrors
         And an FTS probe is triggered
         And the segments are synchronized
         And verify the database has mirrors
+        #gpaddmirrors triggers full recovery where old replication slot is dropped and new one is created
+        And verify replication slot internal_wal_replication_slot is available on all the segments
         And the tablespace is valid
         And user stops all primary processes
         And user can start transactions
@@ -49,8 +53,10 @@ Feature: Tests for gpaddmirrors
 
         When gpaddmirrors adds 3 mirrors
         Then gpaddmirrors should return a return code of 0
+        And gpaddmirrors should not print "Unable to kill walsender on primary" to stdout
         And verify the database has mirrors
         And the segments are synchronized
+        And check segment conf: postgresql.conf
         And user can start transactions
 
     Scenario: gpaddmirrors setup recovery part two
@@ -162,7 +168,7 @@ Feature: Tests for gpaddmirrors
         And the user reset the walsender on the primary on content 0
         And the user waits until saved async process is completed
         And recovery_progress.file should not exist in gpAdminLogs in gpAdminLogs
-        And the user waits until mirror on content 0,1,2 is up
+        And verify that mirror on content 0,1,2 is up
 
         And check if mirrors on content 0,1,2 are moved to new location on input file
         And verify there are no recovery backout files
@@ -174,7 +180,19 @@ Feature: Tests for gpaddmirrors
 
         And all the segments are running
         And the segments are synchronized
+        And check segment conf: postgresql.conf
+        And all files in gpAdminLogs directory are deleted
 
+    Scenario: gpaddmirrors errors out if the directory for the mirror to be added is not empty
+        Given the cluster is generated with "3" primaries only
+        And all files in gpAdminLogs directory are deleted
+        And a gaddmirrors directory under '/tmp' with mode '0700' is created
+        And a gpaddmirrors input file is created
+        And edit the input file to add mirror with content 0,1,2 to a new non-empty directory with mode 0700
+        When the user runs gpaddmirrors with input file and additional args "-a"
+        Then gpaddmirrors should print "Segment directory '/tmp/.*' exists but is not empty!" to stdout
+        And all the segments are running
+        And check segment conf: postgresql.conf
         And all files in gpAdminLogs directory are deleted
 
 
@@ -191,7 +209,7 @@ Feature: Tests for gpaddmirrors
 #        And the user waits until recovery_progress.file is created in gpAdminLogs and verifies its format
 #        And the user waits until saved async process is completed
 #        And recovery_progress.file should not exist in gpAdminLogs
-#        And the user waits until mirror on content 0,1,2 is up
+#        And verify that mirror on content 0,1,2 is up
 #
 #        And check if mirrors on content 0,1,2 are moved to new location on input file
 #        And verify there are no recovery backout files
@@ -214,20 +232,21 @@ Feature: Tests for gpaddmirrors
     Scenario: spread mirroring configuration
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with "spread" segment mirroring on "mdw" and "sdw1, sdw2, sdw3"
+        And a cluster is created with "spread" segment mirroring on "cdw" and "sdw1, sdw2, sdw3"
         Then verify that mirror segments are in "spread" configuration
         Given a preferred primary has failed
         When the user runs "gprecoverseg -a"
         Then gprecoverseg should return a return code of 0
         And all the segments are running
         And the segments are synchronized
+        And check segment conf: postgresql.conf
         And the user runs "gpstop -aqM fast"
 
     @concourse_cluster
     Scenario Outline: gpaddmirrors can add mirrors even if <failed_count> mirrors failed during basebackup
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1, sdw2"
+        And a cluster is created with no mirrors on "cdw" and "sdw1, sdw2"
         And all files in gpAdminLogs directory are deleted on all hosts in the cluster
         And a gpaddmirrors directory under '/tmp' with mode '0700' is created
         And a gpaddmirrors input file is created
@@ -269,7 +288,7 @@ Feature: Tests for gpaddmirrors
     Scenario Outline: gpaddmirrors can add mirrors even if start fails for <failed_count> mirrors
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1, sdw2"
+        And a cluster is created with no mirrors on "cdw" and "sdw1, sdw2"
         And all files in gpAdminLogs directory are deleted on all hosts in the cluster
         And a gpaddmirrors directory under '/tmp' with mode '0700' is created
         And a gpaddmirrors input file is created
@@ -309,13 +328,14 @@ Feature: Tests for gpaddmirrors
     Scenario: gprecoverseg works correctly on a newly added mirror with HBA_HOSTNAMES=0
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And with HBA_HOSTNAMES "0" a cluster is created with no mirrors on "mdw" and "sdw1, sdw2"
+        And with HBA_HOSTNAMES "0" a cluster is created with no mirrors on "cdw" and "sdw1, sdw2"
         And pg_hba file "/tmp/gpaddmirrors/data/primary/gpseg0/pg_hba.conf" on host "sdw1" contains only cidr addresses
         And gpaddmirrors adds mirrors
         And pg_hba file "/tmp/gpaddmirrors/data/primary/gpseg0/pg_hba.conf" on host "sdw1" contains only cidr addresses
         And pg_hba file "/tmp/gpaddmirrors/data/primary/gpseg0/pg_hba.conf" on host "sdw1" contains entries for "samehost"
         And verify that the file "pg_hba.conf" in each segment data directory has "no" line starting with "host.*replication.*\(127.0.0\|::1\).*trust"
         Then verify the database has mirrors
+        And gpaddmirrors should not print "Unable to kill walsender on primary" to stdout
 
         Then the mirror on content 0 is stopped with the immediate flag
         And an FTS probe is triggered
@@ -348,11 +368,12 @@ Feature: Tests for gpaddmirrors
     Scenario: gprecoverseg works correctly on a newly added mirror with HBA_HOSTNAMES=1
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And with HBA_HOSTNAMES "1" a cluster is created with no mirrors on "mdw" and "sdw1, sdw2"
-        And pg_hba file "/tmp/gpaddmirrors/data/primary/gpseg0/pg_hba.conf" on host "sdw1" contains entries for "mdw, sdw1"
+        And with HBA_HOSTNAMES "1" a cluster is created with no mirrors on "cdw" and "sdw1, sdw2"
+        And pg_hba file "/tmp/gpaddmirrors/data/primary/gpseg0/pg_hba.conf" on host "sdw1" contains entries for "cdw, sdw1"
         And gpaddmirrors adds mirrors with options "--hba-hostnames"
-        And pg_hba file "/tmp/gpaddmirrors/data/primary/gpseg0/pg_hba.conf" on host "sdw1" contains entries for "mdw, sdw1, sdw2, samehost"
+        And pg_hba file "/tmp/gpaddmirrors/data/primary/gpseg0/pg_hba.conf" on host "sdw1" contains entries for "cdw, sdw1, sdw2, samehost"
         Then verify the database has mirrors
+        And gpaddmirrors should not print "Unable to kill walsender on primary" to stdout
 
         When the mirror on content 0 is stopped with the immediate flag
         And an FTS probe is triggered
@@ -385,50 +406,56 @@ Feature: Tests for gpaddmirrors
     Scenario: gpaddmirrors puts mirrors on the same hosts when there is a standby configured
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1, sdw2, sdw3"
+        And a cluster is created with no mirrors on "cdw" and "sdw1, sdw2, sdw3"
         And gpaddmirrors adds mirrors
-        Then verify the database has mirrors
+        Then gpaddmirrors should not print "Unable to kill walsender on primary" to stdout
+        And verify the database has mirrors
         And save the gparray to context
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1, sdw2, sdw3"
+        And a cluster is created with no mirrors on "cdw" and "sdw1, sdw2, sdw3"
         And the user runs gpinitstandby with options " "
         Then gpinitstandby should return a return code of 0
         And gpaddmirrors adds mirrors
         Then mirror hostlist matches the one saved in context
+        And check segment conf: postgresql.conf
         And the user runs "gpstop -aqM fast"
 
     @concourse_cluster
     Scenario: gpaddmirrors puts mirrors on different host
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1, sdw2, sdw3"
+        And a cluster is created with no mirrors on "cdw" and "sdw1, sdw2, sdw3"
         And gpaddmirrors adds mirrors in spread configuration
         Then verify that mirror segments are in "spread" configuration
+        And check segment conf: postgresql.conf
         And the user runs "gpstop -aqM fast"
 
     @concourse_cluster
     Scenario: gpaddmirrors with a default coordinator data directory
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And gpaddmirrors adds mirrors
-        Then verify the database has mirrors
+        Then gpaddmirrors should not print "Unable to kill walsender on primary" to stdout
+        And verify the database has mirrors
+        And check segment conf: postgresql.conf
         And the user runs "gpstop -aqM fast"
 
     @concourse_cluster
     Scenario: gpaddmirrors with a given coordinator data directory [-d <coordinator datadir>]
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And gpaddmirrors adds mirrors with temporary data dir
         Then verify the database has mirrors
+        And check segment conf: postgresql.conf
         And the user runs "gpstop -aqM fast"
 
     @concourse_cluster
     Scenario: gpaddmirrors mirrors are recognized after a cluster restart
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         When gpaddmirrors adds mirrors
         Then verify the database has mirrors
         When an FTS probe is triggered
@@ -438,13 +465,25 @@ Feature: Tests for gpaddmirrors
         And wait until the process "gpstart" goes down
         Then all the segments are running
         And the segments are synchronized
+        And check segment conf: postgresql.conf
+        And the user runs "gpstop -aqM fast"
+
+    @concourse_cluster
+    Scenario: gpaddmirrors should create consistent port entry on mirrors postgresql.conf file
+        Given a working directory of the test as '/tmp/gpaddmirrors'
+        And the database is not running
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
+        When gpaddmirrors adds mirrors
+        Then gpaddmirrors should not print "Unable to kill walsender on primary" to stdout
+        And verify the database has mirrors
+        And check segment conf: postgresql.conf
         And the user runs "gpstop -aqM fast"
 
     @concourse_cluster
     Scenario: gpaddmirrors when the primaries have data
         Given a working directory of the test as '/tmp/gpaddmirrors'
         And the database is not running
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And there is a "heap" table "public.heap_table" in "gptest" with "100" rows
         And there is a "ao" table "public.ao_table" in "gptest" with "100" rows
@@ -463,10 +502,11 @@ Feature: Tests for gpaddmirrors
     Scenario: tablespaces work on a multi-host environment
         Given a working directory of the test as '/tmp/gpaddmirrors'
           And the database is not running
-          And a cluster is created with no mirrors on "mdw" and "sdw1"
+          And a cluster is created with no mirrors on "cdw" and "sdw1"
           And a tablespace is created with data
          When gpaddmirrors adds mirrors
-         Then verify the database has mirrors
+         Then gpaddmirrors should not print "Unable to kill walsender on primary" to stdout
+         And verify the database has mirrors
 
          When an FTS probe is triggered
           And the segments are synchronized
diff --git a/gpMgmt/test/behave/mgmt_utils/gpcheckcat.feature b/gpMgmt/test/behave/mgmt_utils/gpcheckcat.feature
index d9b91838909..35f4fb7fbd3 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpcheckcat.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpcheckcat.feature
@@ -9,6 +9,9 @@ Feature: gpcheckcat tests
         Given database "all_good" is dropped and recreated
         Then the user runs "gpcheckcat -A"
         Then gpcheckcat should return a return code of 0
+        When the user runs "gpcheckcat -C pg_class"
+        Then gpcheckcat should return a return code of 0
+        And gpcheckcat should not print "Execution error:" to stdout
         And the user runs "dropdb all_good"
 
     Scenario: gpcheckcat should drop leaked schemas
@@ -155,6 +158,27 @@ Feature: gpcheckcat tests
         And the user runs "dropdb owner_db2"
         And the path "gpcheckcat.repair.*" is removed from current working directory
 
+    Scenario: gpcheckcat should report and repair owner errors on appendonly tables and its indexes
+        Given database "owner_db" is dropped and recreated
+          And the path "gpcheckcat.repair.*" is removed from current working directory
+          And there is a "ao" table "public.gpadmin_ao_tbl" in "owner_db" with data
+          And the user runs "psql owner_db -c "CREATE INDEX gpadmin_ao_tbl_idx on gpadmin_ao_tbl (column1);""
+          And the user runs sql "alter table gpadmin_ao_tbl OWNER TO wolf" in "owner_db" on first primary segment
+         Then psql should return a return code of 0
+
+        When the user runs "gpcheckcat -R owner owner_db"
+         Then gpcheckcat should return a return code of 3
+         Then the path "gpcheckcat.repair.*" is found in cwd "1" times
+
+        When the user runs all the repair scripts in the dir "gpcheckcat.repair.*"
+          And the path "gpcheckcat.repair.*" is removed from current working directory
+          And the user runs "gpcheckcat -R owner owner_db"
+         Then Then gpcheckcat should return a return code of 0
+         Then the path "gpcheckcat.repair.*" is found in cwd "0" times
+
+        And the user runs "dropdb owner_db"
+        And the path "gpcheckcat.repair.*" is removed from current working directory
+        
     Scenario: gpcheckcat should report and repair invalid constraints
         Given database "constraint_db" is dropped and recreated
         And the path "gpcheckcat.repair.*" is removed from current working directory
@@ -435,7 +459,7 @@ Feature: gpcheckcat tests
         Then gpcheckcat should print "Table pg_type has a dependency issue on oid .* at content 0" to stdout
         And the user runs "dropdb gpcheckcat_dependency"
 
-    Scenario: gpcheckcat should report no inconsistency of pg_extension between Master and Segements
+    Scenario: gpcheckcat should report no inconsistency of pg_extension between Coordinator and Segements
         Given database "pgextension_db" is dropped and recreated
         And the user runs sql "set allow_system_table_mods=true;update pg_extension set extconfig='{2130}', extcondition='{2130}';" in "pgextension_db" on first primary segment
         Then the user runs "gpcheckcat -R inconsistent pgextension_db"
@@ -651,11 +675,6 @@ Feature: gpcheckcat tests
         And the user runs "dropdb check_dependency_error"
         And the user runs "psql -d postgres -c "DROP ROLE foo""
 
-
-########################### @concourse_cluster tests ###########################
-# The @concourse_cluster tag denotes the scenario that requires a remote cluster
-
-    @concourse_cluster
     Scenario Outline: gpcheckcat should discover missing attributes for external tables
         Given database "miss_attr_db3" is dropped and recreated
         And the user runs "echo > /tmp/backup_gpfdist_dummy"
@@ -675,42 +694,42 @@ Feature: gpcheckcat tests
             | attrname   | tablename          |
             | ftrelid    | pg_foreign_table   |
 
-# GPDB_12_MERGE_FIXME:
-# 1, this case is removed because 12 partitioning implementation will not record pg_constraint, right?
-# 2, gpcheckcat in the concourse only runs 1 or 2 tests, how about merging into another task?
-#
-#    @concourse_cluster
-#    Scenario Outline: gpcheckcat should discover missing attributes for external tables
-#        Given database "miss_attr_db3" is dropped and recreated
-#        And the user runs "echo > /tmp/backup_gpfdist_dummy"
-#        And the user runs "gpfdist -p 8098 -d /tmp &"
-#        And there is a partition table "part_external" has external partitions of gpfdist with file "backup_gpfdist_dummy" on port "8098" in "miss_attr_db3" with data
-#        Then data for partition table "part_external" with leaf partition distributed across all segments on "miss_attr_db3"
-#        When the user runs "gpcheckcat miss_attr_db3"
-#        And gpcheckcat should return a return code of 0
-#        Then gpcheckcat should not print "Missing" to stdout
-#        And the user runs "psql miss_attr_db3 -c "SET allow_system_table_mods=true; DELETE FROM <tablename> where <attrname>='part_external_1_prt_p_2'::regclass::oid;""
-#        Then psql should return a return code of 0
-#        When the user runs "gpcheckcat miss_attr_db3"
-#        Then gpcheckcat should print "Missing" to stdout
-#        And gpcheckcat should print "part_external_1_prt_p_2_check" to stdout
-#        Examples:
-#            | attrname   | tablename     |
-#            | conrelid   | pg_constraint |
-#
-
-    Scenario: gpcheckcat should discover missing attributes of pg_description catalogue table
-        Given there is a "heap" table "public.heap_table" in "miss_attr_db5" with data and description
-        When the user runs "gpcheckcat -v miss_attr_db5"
+    Scenario Outline: gpcheckcat should discover missing attributes for external tables
+        Given database "miss_attr_db3" is dropped and recreated
+        And the user runs "echo > /tmp/backup_gpfdist_dummy"
+        And the user runs "gpfdist -p 8098 -d /tmp &"
+        And there is a partition table "part_external" has external partitions of gpfdist with file "backup_gpfdist_dummy" on port "8098" in "miss_attr_db3" with data
+        Then data for partition table "part_external" with leaf partition distributed across all segments on "miss_attr_db3"
+        When the user runs "gpcheckcat miss_attr_db3"
         And gpcheckcat should return a return code of 0
         Then gpcheckcat should not print "Missing" to stdout
-        And the user runs "psql miss_attr_db5 -c "SET allow_system_table_mods=true; DELETE FROM pg_description where objoid='heap_table'::regclass::oid;""
+        And the user runs "psql miss_attr_db3 -c "SET allow_system_table_mods=true; DELETE FROM <tablename> where <attrname>='part_external_1_prt_p_2';""
         Then psql should return a return code of 0
-        When the user runs "gpcheckcat -v miss_attr_db5"
+        When the user runs "gpcheckcat miss_attr_db3"
+        Then gpcheckcat should print "Missing" to stdout
+        And gpcheckcat should print "Name of test which found this issue: missing_extraneous_pg_class" to stdout
+        And gpcheckcat should print "Relation name: part_external_1_prt_p_2" to stdout
+        Examples:
+            | attrname   | tablename          |
+            | relname    | pg_class           |
+
+    Scenario: gpcheckcat should discover missing attributes of pg_description and pg_shdescription catalogue table without errors
+        Given database "miss_attr_db5" is dropped and recreated
+        And there is a "heap" table "public.heap_table" in "miss_attr_db5" with data and description
+        And a tablespace is created with data and description
+        When the user runs "gpcheckcat miss_attr_db5"
+        Then gpcheckcat should return a return code of 0
+        And gpcheckcat should not print "Missing" to stdout
+        When the user runs "psql miss_attr_db5 -c "SET allow_system_table_mods=true; DELETE FROM pg_description where objoid='heap_table'::regclass::oid;""
+        Then psql should return a return code of 0
+        When the user runs "psql miss_attr_db5 -c "SET allow_system_table_mods=true; DELETE FROM pg_shdescription where objoid=(SELECT oid from pg_tablespace where spcname='outerspace');""
+        Then psql should return a return code of 0
+        When the user runs "gpcheckcat miss_attr_db5"
         Then gpcheckcat should print "Missing description metadata of {.*} on content -1" to stdout
         And gpcheckcat should not print "Execution error:" to stdout
         And gpcheckcat should print "Name of test which found this issue: missing_extraneous_pg_description" to stdout
-
+        Then gpcheckcat should print "Missing shdescription metadata of {.*} on content -1" to stdout
+        And gpcheckcat should print "Name of test which found this issue: missing_extraneous_pg_shdescription" to stdout
 
     Scenario: set multiple GUC at session level in gpcheckcat
         Given database "all_good" is dropped and recreated
@@ -728,6 +747,13 @@ Feature: gpcheckcat tests
         And the user runs "dropdb all_good"
 
 
+    # The first half needs a postmaster started with gp_role=utility to reject
+    # non-utility connections ("System was started in single node mode - only
+    # utility mode connections are allowed").  Greenplum does that in
+    # InitPostgres(); Cloudberry dropped the check, so the connection succeeds
+    # and gpcheckcat returns 0.  Kept aligned with upstream so the scenario can
+    # be enabled once the check is restored.
+    @not_implemented
     Scenario: validate session GUC passed with -x is set
         Given the database is not running
           And the user runs "gpstart -ma"
@@ -741,5 +767,96 @@ Feature: gpcheckcat tests
           And "gpstop -m" should return a return code of 0
           And the user runs "gpstart -a"
 
-
-
+    Scenario: Validate if gpecheckcat throws error when there are tables created using mix distribution policy
+        Given database "hashops_db" is dropped and recreated
+        And the user runs "psql hashops_db -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql"
+        Then psql should return a return code of 0
+        And the user runs "psql hashops_db -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql"
+        Then psql should return a return code of 0
+        When the user runs "gpcheckcat -R mix_distribution_policy hashops_db "
+        And gpcheckcat should print "Found tables created using both legacy and non legacy hashops in distribution policy." to stdout
+        And gpcheckcat should print "Please run the gpcheckcat.distpolicy.sql file to list the tables." to stdout
+        And the user runs "dropdb hashops_db"
+
+    Scenario: Validate if gpcheckcat succeeds and there are no tables
+        Given database "hashops_db" is dropped and recreated
+        When the user runs "gpcheckcat -R mix_distribution_policy hashops_db"
+        And gpcheckcat should print "PASSED" to stdout
+        And the user runs "dropdb hashops_db"
+
+    Scenario: Validate if gpcheckcat throws error when GUC gp_use_legacy_hashops is on and there are non legacy tables
+        Given database "hashops_db" is dropped and recreated
+        And the user runs "psql hashops_db -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql"
+        Then psql should return a return code of 0
+        And the user runs "gpconfig -c gp_use_legacy_hashops -v on --skipvalidation"
+        Then gpconfig should return a return code of 0
+        And the user runs "gpstop -a"
+        Then gpstop should return a return code of 0
+        And the user runs "gpstart -a"
+        When the user runs "gpcheckcat -R mix_distribution_policy hashops_db"
+        And gpcheckcat should print "GUC gp_use_legacy_hashops is on." to stdout
+        And gpcheckcat should print "all newly created tables will use legacy hash ops by default for hash distributed table," to stdout
+        And gpcheckcat should print "but there are tables using non-legacy hash ops in the cluster." to stdout
+        And gpcheckcat should print "Please run the gpcheckcat.distpolicy.sql file to list the tables." to stdout
+        And the user runs "dropdb hashops_db"
+
+      Scenario: Validate if gpcheckcat succeeds when GUC gp_use_legacy_hashops is on and there are legacy tables
+        Given database "hashops_db" is dropped and recreated
+        And the user runs "psql hashops_db -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql"
+        Then psql should return a return code of 0
+        And the user runs "gpconfig -c gp_use_legacy_hashops -v on --skipvalidation"
+        Then gpconfig should return a return code of 0
+        And the user runs "gpstop -a"
+        Then gpstop should return a return code of 0
+        And the user runs "gpstart -a"
+        When the user runs "gpcheckcat -R mix_distribution_policy hashops_db"
+         And gpcheckcat should print "PASSED" to stdout
+        And the user runs "dropdb hashops_db"
+
+    Scenario: Validate if gpcheckcat throws error when GUC gp_use_legacy_hashops is off and there are legacy tables
+        Given database "hashops_db" is dropped and recreated
+        And the user runs "psql hashops_db -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql"
+        And the user runs "gpconfig -c gp_use_legacy_hashops -v off --skipvalidation"
+        Then gpconfig should return a return code of 0
+        And the user runs "gpstop -a"
+        Then gpstop should return a return code of 0
+        And the user runs "gpstart -a"
+        When the user runs "gpcheckcat -R mix_distribution_policy hashops_db"
+        And gpcheckcat should print "GUC gp_use_legacy_hashops is off." to stdout
+        And gpcheckcat should print "all newly created tables will use non legacy hash ops by default for hash distributed table," to stdout
+        And gpcheckcat should print "but there are tables using legacy hash ops in the cluster." to stdout
+        And gpcheckcat should print "Please run the gpcheckcat.distpolicy.sql file to list the tables." to stdout
+        And the user runs "dropdb hashops_db"
+
+    Scenario: Validate if gpcheckcat succeeds when GUC gp_use_legacy_hashops is off and there are non legacy tables 
+        Given database "hashops_db" is dropped and recreated
+        And the user runs "psql hashops_db -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql"
+        And the user runs "gpconfig -c gp_use_legacy_hashops -v off --skipvalidation"
+        Then gpconfig should return a return code of 0
+        And the user runs "gpstop -a"
+        Then gpstop should return a return code of 0
+        And the user runs "gpstart -a"
+        When the user runs "gpcheckcat -R mix_distribution_policy hashops_db"
+        And gpcheckcat should print "PASSED" to stdout
+        And the user runs "dropdb hashops_db"
+
+    Scenario: gpcheckcat -l should report mix_distribution_policy to stdout
+        When the user runs "gpcheckcat -l "
+        And gpcheckcat should print "mix_distribution_policy" to stdout
+
+    Scenario: gpcheckcat report all tables created using legacy opclass on multiple database
+        Given database "hashops_db" is dropped and recreated
+        And the user runs "psql hashops_db -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql"
+        And the user runs "psql hashops_db -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql"
+        Then psql should return a return code of 0
+        Given database "hashops_db2" is dropped and recreated
+        And the user runs "psql hashops_db2 -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql"
+        And the user runs "psql hashops_db2 -f test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql"
+        Then psql should return a return code of 0
+        When the user runs "gpcheckcat -A -R mix_distribution_policy"
+        And gpcheckcat should print "Found tables created using both legacy and non legacy hashops in distribution policy." to stdout
+        And gpcheckcat should print "Please run the gpcheckcat.distpolicy.sql file to list the tables." to stdout
+        Then gpcheckcat should print "Completed 1 test(s) on database 'hashops_db'" to logfile with latest timestamp
+        Then gpcheckcat should print "Completed 1 test(s) on database 'hashops_db2'" to logfile with latest timestamp
+        And the user runs "dropdb hashops_db"
+        And the user runs "dropdb hashops_db2"
diff --git a/gpMgmt/test/behave/mgmt_utils/gpexpand.feature b/gpMgmt/test/behave/mgmt_utils/gpexpand.feature
index 90bc88836d4..6bf58246def 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpexpand.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpexpand.feature
@@ -7,11 +7,11 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And the coordinator pid has been saved
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         When the user runs gpexpand interview to add 2 new segment and 0 new host "ignored.host"
         Then the number of segments have been saved
         And user has created expansiontest tables
@@ -33,11 +33,11 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And the user runs gpinitstandby with options " "
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         When the user runs gpexpand interview to add 2 new segment and 0 new host "ignored.host"
         Then user has created expansiontest tables
         And 4000000 rows are inserted into table "expansiontest0" in schema "public" with column type list "int"
@@ -53,10 +53,10 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         When the user runs gpexpand interview to add 2 new segment and 0 new host "ignored.host"
         Then the number of segments have been saved
         And user has created expansiontest tables
@@ -76,10 +76,10 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         When the user runs gpexpand interview to add 2 new segment and 0 new host "ignored.host"
         Then the number of segments have been saved
         When the user runs gpexpand with the latest gpexpand_inputfile with additional parameters "--silent"
@@ -91,10 +91,10 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1,sdw2"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1,sdw2"
         And the new host "sdw2" is ready to go
         When the user runs gpexpand interview to add 0 new segment and 1 new host "sdw2"
         Then the number of segments have been saved
@@ -107,10 +107,10 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1,sdw2"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1,sdw2"
         And the new host "sdw2" is ready to go
         When the user runs gpexpand interview to add 1 new segment and 1 new host "sdw2"
         Then the number of segments have been saved
@@ -123,10 +123,10 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         And the number of segments have been saved
         When the user runs gpexpand with a static inputfile for a single-node cluster with mirrors
         Then verify that the cluster has 4 new segments
@@ -137,9 +137,9 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         And the user runs gpexpand with a static inputfile for a two-node cluster with mirrors
         And expanded preferred primary on segment "3" has failed
         When the user runs "gprecoverseg -a"
@@ -157,10 +157,10 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1,sdw2,sdw3"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1,sdw2,sdw3"
         And the new host "sdw2,sdw3" is ready to go
         When the user runs gpexpand interview to add 0 new segment and 2 new host "sdw2,sdw3"
         Then the number of segments have been saved
@@ -174,11 +174,11 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And the user runs gpinitstandby with options " "
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1,sdw2,sdw3"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1,sdw2,sdw3"
         And the new host "sdw2,sdw3" is ready to go
         When the user runs gpexpand interview to add 1 new segment and 2 new host "sdw2,sdw3"
         Then the number of segments have been saved
@@ -192,13 +192,13 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And the user runs gpinitstandby with options " "
         And database "gptest" exists
         And a tablespace is created with data
         And another tablespace is created with data
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1,sdw2,sdw3"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1,sdw2,sdw3"
         And the new host "sdw2,sdw3" is ready to go
         When the user runs gpexpand interview to add 1 new segment and 2 new host "sdw2,sdw3"
         Then the number of segments have been saved
@@ -234,6 +234,59 @@ Feature: expand the cluster by adding more segments
         When the user runs gpexpand to redistribute
         Then the tablespace is valid after gpexpand
 
+    @gpexpand_icproxy
+    Scenario: Cluster expansion failed (no new proxy address) with IC proxy mode enabled
+        Given the database is not running
+        And a working directory of the test as '/data/gpdata/gpexpand'
+        And the user runs command "rm -rf /data/gpdata/gpexpand/*"
+        And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
+        And the coordinator pid has been saved
+        And database "gptest" exists
+        And there are no gpexpand_inputfiles
+        And the cluster is running in IC proxy mode
+        And the cluster is setup for an expansion on hosts "cdw"
+        And the user runs gpexpand interview to add 1 new segment and 0 new host "ignore.host"
+        And the number of segments have been saved
+        When the user runs gpexpand with the latest gpexpand_inputfile without ret code check
+        Then gpexpand should return a return code of 3
+        And gpexpand should print "Checking ICProxy addresses failed" to stdout
+
+    @gpexpand_icproxy
+    Scenario: Cluster expansion failed (bind an wrong proxy address) with IC proxy mode enabled
+        Given the database is not running
+        And a working directory of the test as '/data/gpdata/gpexpand'
+        And the user runs command "rm -rf /data/gpdata/gpexpand/*"
+        And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
+        And the coordinator pid has been saved
+        And database "gptest" exists
+        And there are no gpexpand_inputfiles
+        And the cluster is running in IC proxy mode with new proxy address 4:2:cdw:16502
+        And the cluster is setup for an expansion on hosts "cdw"
+        And the user runs gpexpand interview to add 1 new segment and 0 new host "ignore.host"
+        And the number of segments have been saved
+        When the user runs gpexpand with the latest gpexpand_inputfile without ret code check
+        Then gpexpand should return a return code of 3
+        And gpexpand should print "The ic_proxy process failed to bind or listen" to stdout
+
+    @gpexpand_icproxy
+    Scenario: Cluster expansion successful with IC proxy mode enabled
+        Given the database is not running
+        And a working directory of the test as '/data/gpdata/gpexpand'
+        And the user runs command "rm -rf /data/gpdata/gpexpand/*"
+        And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
+        And the coordinator pid has been saved
+        And database "gptest" exists
+        And there are no gpexpand_inputfiles
+        And the cluster is running in IC proxy mode with new proxy address 4:2:sdw1:16502
+        And the cluster is setup for an expansion on hosts "cdw"
+        And the user runs gpexpand interview to add 1 new segment and 0 new host "ignore.host"
+        And the number of segments have been saved
+        When the user runs gpexpand with the latest gpexpand_inputfile without ret code check
+        Then gpexpand should return a return code of 0
+
     @gpexpand_verify_redistribution
     Scenario: Verify data is correctly redistributed after expansion
         Given the database is not running
@@ -278,11 +331,11 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And the user runs psql with "-f /home/gpadmin/sqldump/dump.sql" against database "gptest"
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1,sdw2,sdw3"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1,sdw2,sdw3"
         And the new host "sdw2,sdw3" is ready to go
         And the user runs gpexpand interview to add 1 new segment and 2 new host "sdw2,sdw3"
         And the number of segments have been saved
@@ -297,11 +350,11 @@ Feature: expand the cluster by adding more segments
         And a working directory of the test as '/data/gpdata/gpexpand'
         And the user runs command "rm -rf /data/gpdata/gpexpand/*"
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And the coordinator pid has been saved
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         And the user runs gpexpand interview to add 2 new segment and 0 new host "ignored.host"
         And the number of segments have been saved
         And user has created test table
@@ -321,11 +374,11 @@ Feature: expand the cluster by adding more segments
         And a working directory of the test as '/data/gpdata/gpexpand'
         And the user runs command "rm -rf /data/gpdata/gpexpand/*"
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And the coordinator pid has been saved
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw"
+        And the cluster is setup for an expansion on hosts "cdw"
         And the user runs gpexpand interview to add 1 new segment and 0 new host "ignore.host"
         And the number of segments have been saved
         When the user runs gpexpand with the latest gpexpand_inputfile with additional parameters "--silent"
@@ -343,14 +396,14 @@ Feature: expand the cluster by adding more segments
         And a working directory of the test as '/data/gpdata/gpexpand'
         And the user runs command "rm -rf /data/gpdata/gpexpand/*"
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And the coordinator pid has been saved
         And database "gptest" exists
         And user has created test table
         And 20 rows are inserted into table "test" in schema "public" with column type list "int"
         And a long-run read-only transaction exists on "test"
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw"
+        And the cluster is setup for an expansion on hosts "cdw"
         And the user runs gpexpand interview to add 1 new segment and 0 new host "ignore.host"
         And the number of segments have been saved
         When the user runs gpexpand with the latest gpexpand_inputfile with additional parameters "--silent"
@@ -368,12 +421,12 @@ Feature: expand the cluster by adding more segments
         And a working directory of the test as '/data/gpdata/gpexpand'
         And the user runs command "rm -rf /data/gpdata/gpexpand/*"
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And the coordinator pid has been saved
         And database "gptest" exists
         And a long-run transaction starts
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw"
+        And the cluster is setup for an expansion on hosts "cdw"
         And the user runs gpexpand interview to add 1 new segment and 0 new host "ignore.host"
         And the number of segments have been saved
         When the user runs gpexpand with the latest gpexpand_inputfile with additional parameters "--silent"
@@ -391,11 +444,11 @@ Feature: expand the cluster by adding more segments
         And a working directory of the test as '/data/gpdata/gpexpand'
         And the user runs command "rm -rf /data/gpdata/gpexpand/*"
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And the coordinator pid has been saved
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw"
+        And the cluster is setup for an expansion on hosts "cdw"
         And the user runs gpexpand interview to add 1 new segment and 0 new host "ignore.host"
         And the number of segments have been saved
         And the transactions are started for dml
@@ -418,11 +471,11 @@ Feature: expand the cluster by adding more segments
         And a working directory of the test as '/tmp/gpexpand_behave'
         And the user runs command "rm -rf /tmp/gpexpand_behave/*"
         And a temporary directory under "/tmp/gpexpand_behave/expandedData" to expand into
-        And a cluster is created with no mirrors on "mdw" and "sdw1"
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And create database schema table with special character
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         And the number of segments have been saved
         And the user runs gpexpand interview to add 1 new segment and 0 new host "ignored.host"
         When the user runs gpexpand with the latest gpexpand_inputfile without ret code check
@@ -492,10 +545,10 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1,sdw2,sdw3"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1,sdw2,sdw3"
         And the new host "sdw2,sdw3" is ready to go
         When the user runs gpexpand interview to add 0 new segment and 2 new host "sdw2,sdw3"
         Then the number of segments have been saved
@@ -507,11 +560,11 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And the user runs gpinitstandby with options " "
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         And the primary on content 0 is stopped
         And user can start transactions
         And an FTS probe is triggered
@@ -524,11 +577,11 @@ Feature: expand the cluster by adding more segments
         Given the database is not running
         And a working directory of the test as '/data/gpdata/gpexpand'
         And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
-        And a cluster is created with mirrors on "mdw" and "sdw1"
+        And a cluster is created with mirrors on "cdw" and "sdw1"
         And the user runs gpinitstandby with options " "
         And database "gptest" exists
         And there are no gpexpand_inputfiles
-        And the cluster is setup for an expansion on hosts "mdw,sdw1"
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
         And the primary on content 0 is stopped
         And user can start transactions
         And an FTS probe is triggered
@@ -540,3 +593,117 @@ Feature: expand the cluster by adding more segments
         When the user runs gpexpand with a static inputfile for a single-node cluster with mirrors without ret code check
         Then gpexpand should return a return code of 0
         And gpexpand should print "One or more segments are either down or not in preferred role." to stdout
+
+    @gpexpand_no_mirrors
+
+    @gpexpand_segment
+    Scenario: Gpexpand should succeed when there has event trigger
+        Given the database is not running
+        And a working directory of the test as '/data/gpdata/gpexpand'
+        And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
+        And the cluster is generated with "1" primaries only
+        And database "gptest" exists
+        And the user runs psql with "-c 'create table t(a int)'" against database "gptest"
+        And create event trigger function
+		And the user runs psql with "-c 'create event trigger log_alter on ddl_command_end execute function notcie_ddl()'" against database "gptest"
+        And there are no gpexpand_inputfiles
+        And the cluster is setup for an expansion on hosts "localhost"
+        When the user runs gpexpand interview to add 1 new segment and 0 new host "ignored.host"
+        Then the number of segments have been saved
+        When the user runs gpexpand with the latest gpexpand_inputfile with additional parameters "--silent"
+        Then verify that the cluster has 1 new segments
+		And the user runs psql with "-c 'alter table t add column b int'" against database "gptest"
+
+    @gpexpand_segment
+    Scenario: expand a cluster and verify necessary catalog tables are copied to new segments
+        Given the database is not running
+        And a working directory of the test as '/data/gpdata/gpexpand'
+        And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
+        And database "gptest" exists
+        And the user runs psql with "-c 'CREATE ROLE abc; ALTER ROLE abc DENY DAY 0 DENY DAY 2 DENY BETWEEN DAY 4 AND DAY 5;'" against database "gptest"
+        And there are no gpexpand_inputfiles
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
+        When the user runs gpexpand interview to add 2 new segment and 0 new host "ignored.host"
+        Then the number of segments have been saved
+        When the user runs gpexpand with the latest gpexpand_inputfile with additional parameters "--silent"
+        Then verify that the cluster has 2 new segments
+        And verify that "pg_description" catalog table is present on new segments
+        And verify that "pg_shdescription" catalog table is present on new segments
+        And verify that "pg_auth_time_constraint" catalog table is present on new segments
+        When the user runs "gpcheckcat gptest"
+        Then gpcheckcat should return a return code of 0
+        And the user runs psql with "-c 'DROP ROLE abc'" against database "gptest"
+
+    @gpexpand_mirrors
+    @gpexpand_segment
+    @gpexpand_verify_catalogs
+    Scenario: expand a cluster that has mirrors and check that gpexpand does not copy extra data directories from master
+        Given the database is not running
+        # need to remove this log because otherwise SCAN_LOG may pick up a previous error/warning in the log
+        And the user runs command "rm -rf ~/gpAdminLogs/gpinitsystem*"
+        And a working directory of the test as '/data/gpdata/gpexpand'
+        And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
+        And a cluster is created with mirrors on "cdw" and "sdw1"
+        And database "gptest" exists
+        And the user runs command "analyzedb -d gptest -a"
+        And there are no gpexpand_inputfiles
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
+        And the number of segments have been saved
+        When the user runs gpexpand with a static inputfile for a single-node cluster with mirrors
+        Then verify that the cluster has 4 new segments
+        And verify that the path "db_dumps" in each segment data directory does not exist
+        And verify that the path "gpperfmon/data" in each segment data directory does not exist
+        And verify that the path "gpperfmon/logs" in each segment data directory does not exist
+        And verify that the path "promote" in each segment data directory does not exist
+        And verify that the path "db_analyze" in each segment data directory does not exist
+
+    @gpexpand_no_mirrors
+    @gpexpand_segment
+    Scenario: gpexpand should skip already expanded/broken tables when redistributing
+        Given the database is not running
+        And a working directory of the test as '/data/gpdata/gpexpand'
+        And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
+        And a cluster is created with no mirrors on "cdw" and "sdw1"
+        And database "gptest" exists
+        And the user runs psql with "-c 'CREATE TABLE test_good_1(a int)'" against database "gptest"
+        And the user runs psql with "-c 'CREATE TABLE test_already_expanded(a int)'" against database "gptest"
+        And the user runs psql with "-c 'CREATE TABLE test_broken(a int)'" against database "gptest"
+        And the user runs psql with "-c 'CREATE TABLE test_good_2(a int)'" against database "gptest"
+        And the user runs sql "DROP TABLE test_broken" in "gptest" on primary segment with content 0
+        And there are no gpexpand_inputfiles
+        And the cluster is setup for an expansion on hosts "cdw,sdw1"
+        When the user runs gpexpand interview to add 2 new segment and 0 new host "ignored.host"
+        Then the number of segments have been saved
+        When the user runs gpexpand with the latest gpexpand_inputfile with additional parameters "--silent"
+        Then verify that the cluster has 2 new segments
+        And the user runs psql with "-c 'ALTER TABLE test_already_expanded expand table'" against database "gptest"
+        When the user runs gpexpand to redistribute
+        Then gpexpand should print "[WARNING]:-Encountered unexpected issue when expanding table gptest.public.test_broken, skipping" escaped to stdout
+        And gpexpand should print "[INFO]:-Table gptest.public.test_already_expanded seems to be already expanded, marking as done" escaped to stdout
+        And table "test_good_1" should be marked as expanded
+        And table "test_good_2" should be marked as expanded
+        And table "test_already_expanded" should be marked as expanded
+        And table "test_broken" should not be marked as expanded
+
+    @gpexpand_no_mirrors
+    @gpexpand_verify_dtx
+    Scenario: Gpexpand should succeed when xlog has DTX info
+        Given the database is not running
+        And a working directory of the test as '/data/gpdata/gpexpand'
+        And a temporary directory under "/data/gpdata/gpexpand/expandedData" to expand into
+        And the cluster is generated with "3" primaries only
+        And database "gptest" exists
+        And the user runs psql with "-c 'create extension IF NOT EXISTS gp_inject_fault;create table ttt(tc1 int);'" against database "gptest"
+        And the user runs psql with "-c "SELECT gp_inject_fault('before_notify_commited_dtx_transaction', 'suspend', dbid) FROM gp_segment_configuration WHERE content = -1 AND role = 'p';"" against database "gptest"
+        And the user runs the command "psql gptest -c 'insert into ttt select generate_series(1,100);'" in the background without sleep
+        And waiting "1" seconds
+        And there are no gpexpand_inputfiles
+        And the cluster is setup for an expansion on hosts "localhost"
+        When the user runs gpexpand interview to add 1 new segment and 0 new host "ignored.host"
+        Then the number of segments have been saved
+        When the user runs gpexpand with the latest gpexpand_inputfile with additional parameters "--silent"
+        And the user runs psql with "-c "SELECT gp_inject_fault('before_notify_commited_dtx_transaction', 'reset', dbid) FROM gp_segment_configuration WHERE content = -1 AND role = 'p';"" against database "gptest"
+        And waiting "1" seconds
+        And the user runs psql with "-c 'drop table ttt;'" against database "gptest"
+        Then verify that the cluster has 1 new segments
diff --git a/gpMgmt/test/behave/mgmt_utils/gpinitsystem.feature b/gpMgmt/test/behave/mgmt_utils/gpinitsystem.feature
index 1d69a5403ff..502e491df9f 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpinitsystem.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpinitsystem.feature
@@ -63,6 +63,14 @@ Feature: gpinitsystem tests
         Given the user runs "gpstate"
          Then gpstate should return a return code of 2
 
+    Scenario: gpinitsystem exits with status 1 when the user provides invalid option
+        Given create demo cluster config
+         When the user runs command "gpinitsystem -a -c ../gpAux/gpdemo/clusterConfigFile --ignore-warnings" eok
+         Then gpinitsystem should return a return code of 1
+          And gpinitsystem should print "Unknown option --ignore-warnings" to stdout
+        Given the user runs "gpstate"
+         Then gpstate should return a return code of 2
+
     Scenario: gpinitsystem creates a cluster when the user confirms the dialog
         Given create demo cluster config
          When the user runs command "echo y | gpinitsystem -c ../gpAux/gpdemo/clusterConfigFile"
@@ -70,6 +78,7 @@ Feature: gpinitsystem tests
         Given the user runs "gpstate"
          Then gpstate should return a return code of 0
 
+    @extended
     Scenario: gpinitsystem creates a backout file when gpinitsystem process terminated
         Given create demo cluster config
         And all files in gpAdminLogs directory are deleted
@@ -84,6 +93,7 @@ Feature: gpinitsystem tests
         And gpinitsystem should return a return code of 0
         And gpintsystem logs should not contain lines about running backout script
 
+    @extended
     Scenario: gpinitsystem creates a backout file when gpcreateseg process terminated
         Given create demo cluster config
         And all files in gpAdminLogs directory are deleted
@@ -97,6 +107,7 @@ Feature: gpinitsystem tests
         And gpinitsystem should return a return code of 0
         And gpintsystem logs should not contain lines about running backout script
 
+    @extended
     Scenario: gpinitsystem does not create or need backout file when user terminated very early
         Given create demo cluster config
         And all files in gpAdminLogs directory are deleted
@@ -320,7 +331,7 @@ Feature: gpinitsystem tests
 
     Scenario: gpinitsystem should pass the default value of trusted_shell properly to gpcreateseg
         Given create demo cluster config
-        When the user runs command "gpinitsystem -a -c ../gpAux/gpdemo/clusterConfigFile -h ../gpAux/gpdemo/hostfile --ignore-warnings"
+        When the user runs command "gpinitsystem -a -c ../gpAux/gpdemo/clusterConfigFile -h ../gpAux/gpdemo/hostfile"
         Then gpinitsystem should return a return code of 0
         When the user runs command "grep -q '.*gpcreateseg\.sh.*Completed .*lalshell.*' ~/gpAdminLogs/gpinitsystem*log"
         Then grep should return a return code of 0
@@ -333,4 +344,3 @@ Feature: gpinitsystem tests
         When the user runs command "grep -q '.*gpcreateseg\.sh.*Completed ssh.*' ~/gpAdminLogs/gpinitsystem*log"
         Then grep should return a return code of 0
         And the user runs command "mv ../gpAux/gpdemo/clusterConfigFile.bak ../gpAux/gpdemo/clusterConfigFile"
-
diff --git a/gpMgmt/test/behave/mgmt_utils/gpmovemirrors.feature b/gpMgmt/test/behave/mgmt_utils/gpmovemirrors.feature
index ed6dda775f4..06aa918bb8f 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpmovemirrors.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpmovemirrors.feature
@@ -26,23 +26,31 @@ Feature: Tests for gpmovemirrors
         Given a standard local demo cluster is created
         And a gpmovemirrors directory under '/tmp/gpmovemirrors' with mode '0700' is created
         And a 'good' gpmovemirrors file is created
+        And verify replication slot internal_wal_replication_slot is available on all the segments
         When the user runs gpmovemirrors
         Then gpmovemirrors should return a return code of 0
         And verify the database has mirrors
+        #gpmovemirrors triggers full recovery where old replication slot is dropped and new one is created
+        And verify replication slot internal_wal_replication_slot is available on all the segments
         And all the segments are running
         And the segments are synchronized
+        And check segment conf: postgresql.conf
         And verify that mirrors are recognized after a restart
 
     Scenario: gpmovemirrors can change the port of mirrors within a single host
         Given a standard local demo cluster is created
         And a gpmovemirrors directory under '/tmp/gpmovemirrors' with mode '0700' is created
         And a 'samedir' gpmovemirrors file is created
+        And verify replication slot internal_wal_replication_slot is available on all the segments
         When the user runs gpmovemirrors
         Then gpmovemirrors should return a return code of 0
         And verify the database has mirrors
+        #gpmovemirrors triggers full recovery where old replication slot is dropped and new one is created
+        And verify replication slot internal_wal_replication_slot is available on all the segments
         And all the segments are running
         And the segments are synchronized
         And verify that mirrors are recognized after a restart
+        And check segment conf: postgresql.conf
 
     Scenario: gpmovemirrors gives a warning when passed identical attributes for new and old mirrors
         Given a standard local demo cluster is created
@@ -56,6 +64,7 @@ Feature: Tests for gpmovemirrors
         And the segments are synchronized
         And verify that mirrors are recognized after a restart
 
+    @skip_cleanup
     Scenario: tablespaces work
         Given a standard local demo cluster is created
           And a tablespace is created with data
@@ -69,6 +78,7 @@ Feature: Tests for gpmovemirrors
           And verify that mirrors are recognized after a restart
           And the tablespace is valid
 
+    @skip_cleanup
     Scenario Outline: gpmovemirrors limits number of parallel processes correctly
         Given the database is running
         And all the segments are running
@@ -102,7 +112,7 @@ Feature: Tests for gpmovemirrors
             add a validation error like both hosts recoverying to the same port - so that the triplet code fails
                 assert that gp_seg_config wasn't updated
         """
-
+    @skip_cleanup
     Scenario Outline: user can <correction> if <failed_count> mirrors failed to move initially
         Given the database is running
         And all the segments are running
@@ -178,6 +188,7 @@ Feature: Tests for gpmovemirrors
         And gprecoverseg should return a return code of 0
         And all the segments are running
         And the segments are synchronized
+        And check segment conf: postgresql.conf
         And user can start transactions
 
 
@@ -199,7 +210,7 @@ Feature: Tests for gpmovemirrors
     And the user reset the walsender on the primary on content 0
     And the user waits until saved async process is completed
     And recovery_progress.file should not exist in gpAdminLogs
-    And the user waits until mirror on content 0,1 is up
+    And verify that mirror on content 0,1 is up
     And check if mirrors on content 0,1 are moved to new location on input file
     And user can start transactions
     And all files in gpAdminLogs directory are deleted on all hosts in the cluster
@@ -223,110 +234,133 @@ Feature: Tests for gpmovemirrors
     And the user reset the walsender on the primary on content 0
     And the user waits until saved async process is completed
     And recovery_progress.file should not exist in gpAdminLogs
-    And the user waits until mirror on content 0,1,2 is up
+    And verify that mirror on content 0,1,2 is up
     And check if mirrors on content 0,1,2 are moved to new location on input file
     And user can start transactions
     And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And the cluster is recovered in full and rebalanced
 
+  @demo_cluster
+  @concourse_cluster
+  @skip_cleanup
+  Scenario: gpmovemirrors gives warning if pg_basebackup is already running for one of the mirrors to be moved
+    Given the database is running
+    And all the segments are running
+    And the segments are synchronized
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And the information of contents 0,1,2 is saved
+    And user immediately stops all mirror processes for content 0,1,2
+    And user can start transactions
+    And the user suspend the walsender on the primary on content 0
+    And the user asynchronously runs "gprecoverseg -aF" and the process is saved
+    And the user just waits until recovery_progress.file is created in gpAdminLogs
+    And user waits until gp_stat_replication table has no pg_basebackup entries for content 1,2
+    And an FTS probe is triggered
+    And the user waits until mirror on content 1,2 is up
+    And verify that mirror on content 0 is down
+    And the gprecoverseg lock directory is removed
+    And user immediately stops all mirror processes for content 1,2
+    And the user waits until mirror on content 1,2 is down
+    And a gpmovemirrors directory under '/tmp' with mode '0700' is created
+    And a gpmovemirrors input file is created
+    And edit the input file to recover mirror with content 0,1,2 to a new directory with mode 0700
+    When the user runs gpmovemirrors with input file and additional args " "
+    Then gprecoverseg should print "Found pg_basebackup running for segments with contentIds [0], skipping recovery of these segments" to logfile
+    And gprecoverseg should return a return code of 0
+    And gpmovemirrors should return a return code of 0
+    And verify that mirror on content 1,2 is up
+    And verify that mirror on content 0 is down
+    And check if mirrors on content 1,2 are moved to new location on input file
+    And check if mirrors on content 0 are in their original configuration
+    And the user reset the walsender on the primary on content 0
+    And the user waits until saved async process is completed
+    And recovery_progress.file should not exist in gpAdminLogs
+    And verify that mirror on content 0 is up
+    And the cluster is recovered in full and rebalanced
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
 
-########################### @concourse_cluster tests ###########################
-# The @concourse_cluster tag denotes the scenario that requires a remote cluster
-
-    @concourse_cluster
-    Scenario: gpmovemirrors can change from group mirroring to spread mirroring
-        Given verify that mirror segments are in "group" configuration
-        And pg_hba file "/data/gpdata/primary/gpseg1/pg_hba.conf" on host "sdw1" contains only cidr addresses
-        And a sample gpmovemirrors input file is created in "spread" configuration
-        When the user runs "gpmovemirrors --input=/tmp/gpmovemirrors_input_spread"
-        Then gpmovemirrors should return a return code of 0
-        # Verify that mirrors are functional in the new configuration
-        Then verify the database has mirrors
-        And all the segments are running
-        And the segments are synchronized
-        And verify that mirror segments are in "spread" configuration
-        And verify that mirrors are recognized after a restart
-        And pg_hba file "/data/gpdata/primary/gpseg1/pg_hba.conf" on host "sdw1" contains only cidr addresses
-        And the information of a "mirror" segment on a remote host is saved
-        When user kills a "mirror" process with the saved information
-        And an FTS probe is triggered
-        And user can start transactions
-        Then the saved "mirror" segment is marked down in config
-        When the user runs "gprecoverseg -a"
-        Then gprecoverseg should return a return code of 0
-        And all the segments are running
-        And the segments are synchronized
-        And the information of the corresponding primary segment on a remote host is saved
-        When user kills a "primary" process with the saved information
-        And an FTS probe is triggered
-        And user can start transactions
-        When the user runs "gprecoverseg -a"
-        Then gprecoverseg should return a return code of 0
-        And all the segments are running
-        And the segments are synchronized
-        When primary and mirror switch to non-preferred roles
-        When the user runs "gprecoverseg -a -r"
-        Then gprecoverseg should return a return code of 0
-        And all the segments are running
-        And the segments are synchronized
+  @demo_cluster
+  @concourse_cluster
+  @skip_cleanup
+  Scenario: gpmovemirrors gives warning if pg_basebackup is already running for some of the mirrors to be moved
+    Given the database is running
+    And all the segments are running
+    And the segments are synchronized
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And the information of contents 0,1,2 is saved
+    And user immediately stops all mirror processes for content 0,1,2
+    And user can start transactions
+    And the user suspend the walsender on the primary on content 0
+    And the user suspend the walsender on the primary on content 1
+    And the user asynchronously runs "gprecoverseg -aF" and the process is saved
+    And the user just waits until recovery_progress.file is created in gpAdminLogs
+    And user waits until gp_stat_replication table has no pg_basebackup entries for content 2
+    And the user waits until mirror on content 2 is up
+    And verify that mirror on content 0,1 is down
+    And the gprecoverseg lock directory is removed
+    And user immediately stops all mirror processes for content 2
+    And the user waits until mirror on content 2 is down
+    And a gpmovemirrors directory under '/tmp' with mode '0700' is created
+    And a gpmovemirrors input file is created
+    And edit the input file to recover mirror with content 0,1,2 to a new directory with mode 0700
+    When the user runs gpmovemirrors with input file and additional args " "
+    Then gprecoverseg should print "Found pg_basebackup running for segments with contentIds [0, 1], skipping recovery of these segments" to logfile
+    And gprecoverseg should return a return code of 0
+    And gpmovemirrors should return a return code of 0
+    And verify that mirror on content 2 is up
+    And verify that mirror on content 0,1 is down
+    And check if mirrors on content 2 are moved to new location on input file
+    And check if mirrors on content 0,1 are in their original configuration
+    And the user reset the walsender on the primary on content 0
+    And the user reset the walsender on the primary on content 1
+    And the user waits until saved async process is completed
+    And recovery_progress.file should not exist in gpAdminLogs
+    And verify that mirror on content 0,1 is up
+    And the cluster is recovered in full and rebalanced
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
 
-    @concourse_cluster
-    Scenario: gpmovemirrors can change from spread mirroring to group mirroring
-        Given verify that mirror segments are in "spread" configuration
-        And a sample gpmovemirrors input file is created in "group" configuration
-        When the user runs "gpmovemirrors --input=/tmp/gpmovemirrors_input_group --hba-hostnames"
-        Then gpmovemirrors should return a return code of 0
-        # Verify that mirrors are functional in the new configuration
-        Then verify the database has mirrors
-        And all the segments are running
-        And the segments are synchronized
-        # gpmovemirrors_input_group moves mirror on sdw3 to sdw2, corresponding primary should now have sdw2 entry
-        And pg_hba file "/data/gpdata/primary/gpseg1/pg_hba.conf" on host "sdw1" contains entries for "sdw2"
-        And verify that mirror segments are in "group" configuration
-        And verify that mirrors are recognized after a restart
-        And the information of a "mirror" segment on a remote host is saved
-        When user kills a "mirror" process with the saved information
-        And an FTS probe is triggered
-        And user can start transactions
-        Then the saved "mirror" segment is marked down in config
-        When the user runs "gprecoverseg -a"
-        Then gprecoverseg should return a return code of 0
-        And all the segments are running
-        And the segments are synchronized
-        And the information of the corresponding primary segment on a remote host is saved
-        When user kills a "primary" process with the saved information
-        And an FTS probe is triggered
-        And user can start transactions
-        When the user runs "gprecoverseg -a"
-        Then gprecoverseg should return a return code of 0
-        And all the segments are running
-        And the segments are synchronized
-        When primary and mirror switch to non-preferred roles
-        When the user runs "gprecoverseg -a -r"
-        Then gprecoverseg should return a return code of 0
-        And all the segments are running
-        And the segments are synchronized
+  @demo_cluster
+  @concourse_cluster
+  @skip_cleanup
+  Scenario: gpmovemirrors gives warning if pg_basebackup is already running for all mirrors to be moved
+    Given the database is running
+    And all the segments are running
+    And the segments are synchronized
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And the information of contents 0,1,2 is saved
+    And a gprecoverseg directory under '/tmp' with mode '0700' is created
+    And a gprecoverseg input file is created
+    And edit the input file to recover mirror with content 0 to a new directory on remote host with mode 0700
+    And edit the input file to recover mirror with content 1 to a new directory on remote host with mode 0700
+    And edit the input file to recover mirror with content 2 to a new directory on remote host with mode 0700
+    And user immediately stops all mirror processes for content 0,1,2
+    And user can start transactions
+    And the user suspend the walsender on the primary on content 0
+    And the user suspend the walsender on the primary on content 1
+    And the user suspend the walsender on the primary on content 2
+    When the user asynchronously runs gprecoverseg with input file and additional args "-a" and the process is saved
+    And the user just waits until recovery_progress.file is created in gpAdminLogs
+    And verify that mirror on content 0,1,2 is down
+    And the gprecoverseg lock directory is removed
+    Given a gpmovemirrors directory under '/tmp' with mode '0700' is created
+    And a gpmovemirrors input file is created
+    And edit the input file to recover mirror with content 0,1,2 to a new directory with mode 0700
+    When the user runs gpmovemirrors with input file and additional args "-v"
+    And gprecoverseg should return a return code of 0
+    And gpmovemirrors should return a return code of 0
+    Then gprecoverseg should print "Found pg_basebackup running for segments with contentIds [0, 1, 2], skipping recovery of these segments" to logfile
+    And the user reset the walsender on the primary on content 0
+    And the user reset the walsender on the primary on content 1
+    And the user reset the walsender on the primary on content 2
+    And the user waits until saved async process is completed
+    And recovery_progress.file should not exist in gpAdminLogs
+    And verify that mirror on content 0,1,2 is up
+    And the cluster is recovered in full and rebalanced
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
 
-    @concourse_cluster
-    Scenario: tablespaces work on a multi-host environment
-        Given verify that mirror segments are in "group" configuration
-          And a tablespace is created with data
-          And a sample gpmovemirrors input file is created in "spread" configuration
-         When the user runs "gpmovemirrors --input=/tmp/gpmovemirrors_input_spread"
-         Then gpmovemirrors should return a return code of 0
-          And verify the tablespace directories on host "sdw2" for content "1" are deleted
-          And verify the tablespace directories on host "sdw1" for content "5" are deleted
-          And verify the tablespace directories on host "sdw3" for content "1" are valid
-          And verify the tablespace directories on host "sdw2" for content "5" are valid
-          And verify the database has mirrors
-          And all the segments are running
-          And the segments are synchronized
-          And verify that mirrors are recognized after a restart
-          And the tablespace is valid
 
-         When user stops all primary processes
-          And user can start transactions
-         Then the tablespace is valid
-          And the cluster is recovered in full and rebalanced
+########################### @concourse_cluster tests ###########################
+# The @concourse_cluster tag denotes the scenario that requires a remote cluster
 
     @concourse_cluster
     Scenario: gpmovemirrors mirrors come up even if one pg_ctl_start fails
@@ -353,13 +387,14 @@ Feature: Tests for gpmovemirrors
         And gprecoverseg should print "Initiating segment recovery." to stdout
 
         And check if mirrors on content 0,1,2 are moved to new location on input file
-        And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
+        And gpAdminLogs directory has "pg_basebackup*" files on respective hosts only for content 0,1,2
         And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
         And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
         And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
 
         And the mode of all the created data directories is changed to 0700
         And the cluster is recovered in full and rebalanced
+        And check segment conf: postgresql.conf
         And the row count from table "test_movemirrors" in "postgres" is verified against the saved data
 
     @concourse_cluster
@@ -370,6 +405,7 @@ Feature: Tests for gpmovemirrors
         And the segments are synchronized
         And all files in gpAdminLogs directory are deleted on all hosts in the cluster
         And the information of contents 0,1,2 is saved
+        And check segment conf: postgresql.conf
 
         And sql "DROP TABLE if exists test_movemirrors; CREATE TABLE test_movemirrors AS SELECT generate_series(1,10000) AS i" is executed in "postgres" db
         And the "test_movemirrors" table row count in "postgres" is saved
@@ -387,13 +423,15 @@ Feature: Tests for gpmovemirrors
         And check if mirrors on content 0 are in their original configuration
         And check if mirrors on content 1,2 are moved to new location on input file
         And verify that mirror on content 1,2,3,4,5 is up
-        And gpAdminLogs directory has "pg_basebackup*" files on respective hosts only for content 0
+        And gpAdminLogs directory has "pg_basebackup*" files on respective hosts only for content 0,1,2
         And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
         And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
         And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
+        And check segment conf: postgresql.conf
 
         And the mode of all the created data directories is changed to 0700
         And the cluster is recovered in full and rebalanced
+        And check segment conf: postgresql.conf
         And the row count from table "test_movemirrors" in "postgres" is verified against the saved data
 
     @concourse_cluster
@@ -404,6 +442,7 @@ Feature: Tests for gpmovemirrors
         And the segments are synchronized
         And all files in gpAdminLogs directory are deleted on all hosts in the cluster
         And the information of contents 0,1,2,3,4,5 is saved
+        And check segment conf: postgresql.conf
 
         And sql "DROP TABLE if exists test_movemirrors; CREATE TABLE test_movemirrors AS SELECT generate_series(1,10000) AS i" is executed in "postgres" db
         And the "test_movemirrors" table row count in "postgres" is saved
@@ -424,9 +463,11 @@ Feature: Tests for gpmovemirrors
         And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
         And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
         And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
+        And check segment conf: postgresql.conf
 
         And the mode of all the created data directories is changed to 0700
         And the cluster is recovered in full and rebalanced
+        And check segment conf: postgresql.conf
         And the row count from table "test_movemirrors" in "postgres" is verified against the saved data
 
     @concourse_cluster
@@ -437,6 +478,7 @@ Feature: Tests for gpmovemirrors
         And the segments are synchronized
         And all files in gpAdminLogs directory are deleted on all hosts in the cluster
         And the information of contents 0,1,2,3,4,5 is saved
+        And check segment conf: postgresql.conf
 
         And sql "DROP TABLE if exists test_movemirrors; CREATE TABLE test_movemirrors AS SELECT generate_series(1,10000) AS i" is executed in "postgres" db
         And the "test_movemirrors" table row count in "postgres" is saved
@@ -459,7 +501,11 @@ Feature: Tests for gpmovemirrors
         And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
         And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
         And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
+        And check segment conf: postgresql.conf
 
         And the mode of all the created data directories is changed to 0700
         And the cluster is recovered in full and rebalanced
+        And check segment conf: postgresql.conf
         And the row count from table "test_movemirrors" in "postgres" is verified against the saved data
+
+
diff --git a/gpMgmt/test/behave/mgmt_utils/gprecoverseg.feature b/gpMgmt/test/behave/mgmt_utils/gprecoverseg.feature
index 3d28dfc11d5..75ccdf293a3 100644
--- a/gpMgmt/test/behave/mgmt_utils/gprecoverseg.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gprecoverseg.feature
@@ -1,52 +1,97 @@
 @gprecoverseg
 Feature: gprecoverseg tests
 
-    Scenario: incremental recovery works with tablespaces
+    @differential
+    Scenario: differential recovery runs successfully
         Given the database is running
-          And a tablespace is created with data
+          And the segments are synchronized
+          And verify replication slot internal_wal_replication_slot is available on all the segments
           And user stops all primary processes
           And user can start transactions
-         When the user runs "gprecoverseg -a"
+         When the user runs "gprecoverseg -av --differential"
          Then gprecoverseg should return a return code of 0
+          And gprecoverseg should print "Successfully dropped replication slot internal_wal_replication_slot" to stdout
+          And gprecoverseg should print "Successfully created replication slot internal_wal_replication_slot" to stdout
+          And gprecoverseg should print "Segments successfully recovered" to stdout
+          And verify that mirror on content 0,1,2 is up
+          And verify replication slot internal_wal_replication_slot is available on all the segments
           And the segments are synchronized
-          And the tablespace is valid
-          And the database segments are in execute mode
+          And the cluster is rebalanced
 
-        Given another tablespace is created with data
-         When the user runs "gprecoverseg -ra"
-         Then gprecoverseg should return a return code of 0
-          And the segments are synchronized
-          And the tablespace is valid
-          And the other tablespace is valid
-          And the database segments are in execute mode
-      Examples:
-        | scenario     | args               |
-        | incremental  | -a                 |
-        | differential | -a --differential  |
-        | full         | -aF                |
 
-    Scenario: full recovery works with tablespaces
+    # Differential recovery is not implemented in Cloudberry yet. These stay
+    # aligned with Greenplum so they can be enabled along with the feature.
+    @differential
+    Scenario: differential recovery shows error message if run with the wrong argument
+      Given the database is running
+        And user stops all primary processes
+        And user can start transactions
+        And a gprecoverseg directory under '/tmp' with mode '0700' is created
+        And a gprecoverseg input file is created
+       When the user runs "gprecoverseg -a --differential -F"
+       Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "Only one of -F and --differential may be specified" to stdout
+       When the user runs "gprecoverseg -a --differential -p localhost"
+       Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "Only one of -p, -r and --differential may be specified" to stdout
+       When the user runs "gprecoverseg -a --differential -o outputConfigFile"
+       Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "Invalid -o provided with --differential argument" to stdout
+       When the user runs "gprecoverseg -a --differential"
+       Then gprecoverseg should return a return code of 0
+        And the segments are synchronized
+        And the cluster is rebalanced
+
+
+    @demo_cluster
+    @concourse_cluster
+    @differential
+    Scenario: Differential recovery succeeds if previous incremental recovery failed
         Given the database is running
-          And a tablespace is created with data
           And user stops all primary processes
           And user can start transactions
-         When the user runs "gprecoverseg -a -F"
+          And all files in pg_wal directory are deleted from data directory of preferred primary of content 0,1,2
+         When the user runs "gprecoverseg -a"
+         Then gprecoverseg should return a return code of 1
+          And user can start transactions
+          And verify that mirror on content 0,1,2 is down
+         When the user runs "gprecoverseg -a --differential"
          Then gprecoverseg should return a return code of 0
-          And the segments are synchronized
-          And the tablespace is valid
+          And verify that mirror on content 0,1,2 is up
+          And verify replication slot internal_wal_replication_slot is available on all the segments
+          And the cluster is rebalanced
 
-        Given another tablespace is created with data
-         When the user runs "gprecoverseg -ra"
+    @demo_cluster
+    @concourse_cluster
+    @differential
+    Scenario: Differential recovery succeeds if previous full recovery failed
+        Given the database is running
+          And user stops all primary processes
+          And user can start transactions
+          And a gprecoverseg directory under '/tmp' with mode '0700' is created
+          And a gprecoverseg input file is created
+          And edit the input file to recover mirror with content 0 incremental
+          And edit the input file to recover mirror with content 1 full inplace
+          And edit the input file to recover mirror with content 2 to a new directory on remote host with mode 0000
+         When the user runs gprecoverseg with input file and additional args "-a"
+         Then gprecoverseg should return a return code of 1
+          And user can start transactions
+          And verify that mirror on content 0,1 is up
+          And verify that mirror on content 2 is down
+         When the user runs "gprecoverseg -a --differential"
          Then gprecoverseg should return a return code of 0
-          And the segments are synchronized
-          And the tablespace is valid
-          And the other tablespace is valid
+          And verify that mirror on content 0,1,2 is up
+          And verify replication slot internal_wal_replication_slot is available on all the segments
+          And the cluster is rebalanced
+
+
+
 
     Scenario Outline: full recovery limits number of parallel processes correctly
-        Given a standard local demo cluster is created
+        Given the database is running
         And 2 gprecoverseg directory under '/tmp/recoverseg' with mode '0700' is created
         And a good gprecoverseg input file is created for moving 2 mirrors
-        When the user runs gprecoverseg with input file and additional args "-a -F -v <args>"
+        When the user runs gprecoverseg with input file and additional args "-a -v <args>"
         Then gprecoverseg should return a return code of 0
         And gprecoverseg should only spawn up to <coordinator_workers> workers in WorkerPool
         And check if gprecoverseg ran "$GPHOME/sbin/gpsegsetuprecovery.py" 1 times with args "-b <segHost_workers>"
@@ -55,6 +100,7 @@ Feature: gprecoverseg tests
         And gpsegrecovery should only spawn up to <segHost_workers> workers in WorkerPool
         And check if gprecoverseg ran "$GPHOME/sbin/gpsegstop.py" 1 times with args "-b <segHost_workers>"
         And the segments are synchronized
+        And check segment conf: postgresql.conf
 
       Examples:
         | args      | coordinator_workers | segHost_workers |
@@ -62,6 +108,24 @@ Feature: gprecoverseg tests
         | -B 2 -b 1 |  2                  |  1              |
         | -B 1 -b 2 |  1                  |  2              |
 
+    # Differential recovery is not implemented in Cloudberry yet. These stay
+    # aligned with Greenplum so they can be enabled along with the feature.
+    @differential
+    Scenario: Differential recovery limits number of parallel processes correctly
+        Given the database is running
+        And user immediately stops all primary processes for content 0,1,2
+        And user can start transactions
+        When the user runs "gprecoverseg -av --differential -B 1 -b 2"
+        Then gprecoverseg should return a return code of 0
+        And gprecoverseg should only spawn up to 1 workers in WorkerPool
+        And check if gprecoverseg ran "$GPHOME/sbin/gpsegsetuprecovery.py" 1 times with args "-b 2"
+        And check if gprecoverseg ran "$GPHOME/sbin/gpsegrecovery.py" 1 times with args "-b 2"
+        And gpsegsetuprecovery should only spawn up to 2 workers in WorkerPool
+        And gpsegrecovery should only spawn up to 2 workers in WorkerPool
+        And the segments are synchronized
+        And check segment conf: postgresql.conf
+        And the cluster is rebalanced
+
     Scenario Outline: Rebalance correctly limits the number of concurrent processes
       Given the database is running
       And user stops all primary processes
@@ -78,6 +142,7 @@ Feature: gprecoverseg tests
       And check if gprecoverseg ran "$GPHOME/sbin/gpsegrecovery.py" 1 times with args "-b <segHost_workers>"
       And check if gprecoverseg ran "$GPHOME/sbin/gpsegstop.py" 1 times with args "-b <segHost_workers>"
       And the segments are synchronized
+      And check segment conf: postgresql.conf
 
     Examples:
       | args      | coordinator_workers | segHost_workers |
@@ -98,72 +163,49 @@ Feature: gprecoverseg tests
         When the user runs "gprecoverseg -ra"
         Then gprecoverseg should return a return code of 0
         And gprecoverseg should not print "Unhandled exception in thread started by <bound method Worker.__bootstrap" to stdout
-	And the segments are synchronized
+	    And the segments are synchronized
 
     Scenario: gprecoverseg full recovery displays pg_basebackup progress to the user
         Given the database is running
         And all the segments are running
         And the segments are synchronized
+        And all files in gpAdminLogs directory are deleted on all hosts in the cluster
         And user stops all mirror processes
         When user can start transactions
         And the user runs "gprecoverseg -F -a -s"
         Then gprecoverseg should return a return code of 0
         And gprecoverseg should print "pg_basebackup: base backup completed" to stdout for each mirror
         And gprecoverseg should print "Segments successfully recovered" to stdout
-        And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
-        And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
+        And gpAdminLogs directory has "pg_basebackup*" files on all segment hosts
         And gpAdminLogs directory has "gpsegrecovery*" files
         And gpAdminLogs directory has "gpsegsetuprecovery*" files
         And all the segments are running
         And the segments are synchronized
-
-    Scenario: gprecoverseg full recovery displays pg_controldata success info
-        Given the database is running
-        And all the segments are running
-        And the segments are synchronized
-        And user stops all mirror processes
-        When user can start transactions
-        And the user runs "gprecoverseg -F -a"
-        Then gprecoverseg should return a return code of 0
-        And gprecoverseg should print "Successfully finished pg_controldata.* for dbid.*" to stdout
-        And the segments are synchronized
         And check segment conf: postgresql.conf
 
-    Scenario: gprecoverseg incremental recovery displays pg_controldata success info
-        Given the database is running
-        And all the segments are running
-        And the segments are synchronized
-        And user stops all mirror processes
-        When user can start transactions
-        And the user runs "gprecoverseg -a"
-        Then gprecoverseg should return a return code of 0
-        And gprecoverseg should print "Successfully finished pg_controldata.* for dbid.*" to stdout
-        And the segments are synchronized
-        And check segment conf: postgresql.conf
 
-    Scenario: gprecoverseg full recovery displays pg_controldata success info
+    Scenario Outline: gprecoverseg <scenario> recovery displays pg_controldata success info
         Given the database is running
         And all the segments are running
         And the segments are synchronized
         And user stops all mirror processes
         When user can start transactions
-        And the user runs "gprecoverseg -F -a"
+        And the user runs "gprecoverseg <args>"
         Then gprecoverseg should return a return code of 0
         And gprecoverseg should print "Successfully finished pg_controldata.* for dbid.*" to stdout
         And the segments are synchronized
+        And verify replication slot internal_wal_replication_slot is available on all the segments
         And check segment conf: postgresql.conf
 
-    Scenario: gprecoverseg incremental recovery displays pg_controldata success info
-        Given the database is running
-        And all the segments are running
-        And the segments are synchronized
-        And user stops all mirror processes
-        When user can start transactions
-        And the user runs "gprecoverseg -a"
-        Then gprecoverseg should return a return code of 0
-        And gprecoverseg should print "Successfully finished pg_controldata.* for dbid.*" to stdout
-        And the segments are synchronized
-        And check segment conf: postgresql.conf
+      Examples:
+        | scenario     | args               |
+        | incremental  | -a                 |
+        | full         | -aF                |
+
+      @differential
+      Examples:
+        | scenario     | args               |
+        | differential | -a --differential  |
 
     Scenario: gprecoverseg mixed recovery displays pg_basebackup and rewind progress to the user
       Given the database is running
@@ -186,8 +228,8 @@ Feature: gprecoverseg tests
       And gprecoverseg should print "Segments successfully recovered" to stdout
       And check if gprecoverseg ran gpsegsetuprecovery.py 1 times with the expected args
       And check if gprecoverseg ran gpsegrecovery.py 1 times with the expected args
-      And gpAdminLogs directory has no "pg_basebackup*" files
-      And gpAdminLogs directory has no "pg_rewind*" files
+      And gpAdminLogs directory has "pg_basebackup*" files
+      And gpAdminLogs directory has "pg_rewind*" files
       And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
       And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
       And the old data directories are cleaned up for content 0
@@ -208,7 +250,7 @@ Feature: gprecoverseg tests
         When the user runs "gprecoverseg -a -s"
         Then gprecoverseg should return a return code of 0
         And gprecoverseg should print "pg_rewind: Done!" to stdout for each mirror
-        And gpAdminLogs directory has no "pg_rewind*" files
+        And gpAdminLogs directory has "pg_rewind*" files
         And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
         And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
 
@@ -226,7 +268,7 @@ Feature: gprecoverseg tests
         Then gprecoverseg should return a return code of 0
         And gprecoverseg should print "Initiating segment recovery. Upon completion, will start the successfully recovered segments" to stdout
         And gprecoverseg should not print "pg_basebackup: base backup completed" to stdout
-        And gpAdminLogs directory has no "pg_basebackup*" files
+        And gpAdminLogs directory has "pg_basebackup*" files
         And all the segments are running
         And the segments are synchronized
 
@@ -256,6 +298,9 @@ Feature: gprecoverseg tests
           And all the segments are running
           And the segments are synchronized
 
+    # Differential recovery is not implemented in Cloudberry yet. These stay
+    # aligned with Greenplum so they can be enabled along with the feature.
+    @differential
     Scenario: gprecoverseg differential recovery displays rsync progress to the user
         Given the database is running
         And all the segments are running
@@ -268,9 +313,7 @@ Feature: gprecoverseg tests
         And gprecoverseg should print "Initiating segment recovery. Upon completion, will start the successfully recovered segments" to stdout
         And gprecoverseg should print "total size" to stdout for each mirror
         And gprecoverseg should print "Segments successfully recovered" to stdout
-        And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
-        And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
-        And gpAdminLogs directory has no "rsync*" files on all segment hosts
+        And gpAdminLogs directory has "rsync*" files on all segment hosts
         And gpAdminLogs directory has "gpsegrecovery*" files
         And gpAdminLogs directory has "gpsegsetuprecovery*" files
         And all the segments are running
@@ -278,6 +321,9 @@ Feature: gprecoverseg tests
         And verify replication slot internal_wal_replication_slot is available on all the segments
         And check segment conf: postgresql.conf
 
+    # Differential recovery is not implemented in Cloudberry yet. These stay
+    # aligned with Greenplum so they can be enabled along with the feature.
+    @differential
     Scenario: gprecoverseg does not display rsync progress to the user when --no-progress option is specified
         Given the database is running
         And all the segments are running
@@ -290,9 +336,7 @@ Feature: gprecoverseg tests
         And gprecoverseg should print "Initiating segment recovery. Upon completion, will start the successfully recovered segments" to stdout
         And gprecoverseg should not print "total size is .*  speedup is .*" to stdout
         And gprecoverseg should print "Segments successfully recovered" to stdout
-        And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
-        And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
-        And gpAdminLogs directory has no "rsync*" files on all segment hosts
+        And gpAdminLogs directory has "rsync*" files on all segment hosts
         And gpAdminLogs directory has "gpsegrecovery*" files
         And gpAdminLogs directory has "gpsegsetuprecovery*" files
         And all the segments are running
@@ -371,11 +415,61 @@ Feature: gprecoverseg tests
         When the user runs "gprecoverseg -a -s"
         And gprecoverseg should print "skipping pg_rewind on mirror as standby.signal is present" to stdout
         Then gprecoverseg should return a return code of 0
-        And gpAdminLogs directory has no "pg_rewind*" files
+        And gpAdminLogs directory has "pg_rewind*" files
         And all the segments are running
         And the segments are synchronized
         And the cluster is rebalanced
 
+    Scenario: gprecoverseg should drop existing slot on full recovery
+        Given the database is running
+        And all the segments are running
+        And the segments are synchronized
+        And verify replication slot internal_wal_replication_slot is available on all the segments
+        And user stops all mirror processes
+        And user can start transactions
+        And the user waits until mirror on content 0,1,2 is down
+        When the user runs "gprecoverseg -a -F -v"
+        Then gprecoverseg should return a return code of 0
+        And gprecoverseg should print "Checking if slot internal_wal_replication_slot exists" to stdout
+        And gprecoverseg should print "Successfully dropped replication slot internal_wal_replication_slot" to stdout
+        And gprecoverseg should print "pg_basebackup: base backup completed" to stdout
+        And gprecoverseg should print "Segments successfully recovered" to stdout
+        And verify that mirror on content 0,1,2 is up
+        And verify replication slot internal_wal_replication_slot is available on all the segments
+        And all the segments are running
+        And the segments are synchronized
+        And the cluster is rebalanced
+
+    Scenario Outline: <scenario> recovery should not try to drop slot if slot does not exist
+        Given the database is running
+        And all the segments are running
+        And the segments are synchronized
+        And verify replication slot internal_wal_replication_slot is available on all the segments
+        And the mirror on content 0 is stopped
+        And user can start transactions
+        And the status of the mirror on content 0 should be "d"
+        And the user runs sql "select pg_drop_replication_slot('internal_wal_replication_slot');" in "postgres" on first primary segment
+        When the user runs "gprecoverseg <args>"
+        Then gprecoverseg should return a return code of 0
+        And gprecoverseg should print "Checking if slot internal_wal_replication_slot exists" to stdout
+        And gprecoverseg should print "Slot internal_wal_replication_slot does not exist" to stdout
+        And gprecoverseg should not print "Successfully dropped replication slot internal_wal_replication_slot" to stdout
+        And gprecoverseg should print "Segments successfully recovered" to stdout
+        And verify that mirror on content 0 is up
+        And verify replication slot internal_wal_replication_slot is available on all the segments
+        And all the segments are running
+        And the segments are synchronized
+        And the cluster is rebalanced
+
+      Examples:
+        | scenario     | args                |
+        | full         | -avF                |
+
+      @differential
+      Examples:
+        | scenario     | args                |
+        | differential | -av --differential  |
+
     @backup_restore_bashrc
     Scenario: gprecoverseg should not return error when banner configured on host
         Given the database is running
@@ -390,6 +484,49 @@ Feature: gprecoverseg tests
         And the segments are synchronized
         And the cluster is rebalanced
 
+    Scenario: gprecoverseg errors out with restricted options
+      Given the database is running
+        And user stops all primary processes
+        And user can start transactions
+       When the user runs "gprecoverseg -a -F -r"
+       Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "-F option is not supported with -r option" to stdout
+       When the user runs "gprecoverseg -a -p localhost -F"
+       Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "-F option is not supported with -p option" to stdout
+       When the user runs "gprecoverseg xyz"
+       Then gprecoverseg should return a return code of 2
+       And gprecoverseg should print "Recovers a primary or mirror segment instance" to stdout
+       And gprecoverseg should print "too many arguments: only options may be specified" to stdout
+       When the user runs "gprecoverseg -a"
+       Then gprecoverseg should return a return code of 0
+        And the segments are synchronized
+        And the cluster is rebalanced
+
+    Scenario: gprecoverseg recovers segment for valid max-rate options and errors out for others
+      Given the database is running
+        And all the segments are running
+        And the segments are synchronized
+      When user stops all primary processes
+        And user can start transactions
+        And the user runs "gprecoverseg -aF --max-rate 30"
+      Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "error: transfer rate 30 is out of range" to stdout
+      When the user runs "gprecoverseg -aF --max-rate k35"
+      Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "error: transfer rate k35 is not a valid value" to stdout
+      When the user runs "gprecoverseg -aF --max-rate 0"
+      Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "error: Transfer rate must be greater than zero" to stdout
+      When the user runs "gprecoverseg -aF --max-rate 32G"
+      Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "error: Invalid --max-rate unit: G" to stdout
+      When the user runs "gprecoverseg -aF --max-rate 104857.6k"
+      Then gprecoverseg should return a return code of 0
+        And gprecoverseg should print "Segments successfully recovered" to stdout
+        And gprecoverseg should print "Maximum Transfer Rate.*= 104857.6k" to stdout
+        And the segments are synchronized
+        And the cluster is rebalanced
 
 ########################### @concourse_cluster tests ###########################
 # The @concourse_cluster tag denotes the scenario that requires a remote cluster
@@ -430,92 +567,26 @@ Feature: gprecoverseg tests
       And the cluster is returned to a good state
 
       Examples:
-        | scenario    | args |
-        | incremental | -a   |
-        | full        | -aF  |
-
-  @concourse_cluster
-  Scenario: incremental recovery works with tablespaces on a multi-host environment
-    Given the database is running
-    And a tablespace is created with data
-    And user stops all primary processes
-    And user can start transactions
-    When the user runs "gprecoverseg -a"
-    Then gprecoverseg should return a return code of 0
-    And the segments are synchronized
-    And the tablespace is valid
-    And the database segments are in execute mode
-
-    Given another tablespace is created with data
-    When the user runs "gprecoverseg -ra"
-    Then gprecoverseg should return a return code of 0
-    And the segments are synchronized
-    And the tablespace is valid
-    And the other tablespace is valid
-    And the database segments are in execute mode
-
-  @concourse_cluster
-  Scenario: full recovery works with tablespaces on a multi-host environment
-    Given the database is running
-    And a tablespace is created with data
-    And user stops all primary processes
-    And user can start transactions
-    When the user runs "gprecoverseg -a -F"
-    Then gprecoverseg should return a return code of 0
-    And the segments are synchronized
-    And the tablespace is valid
-
-    Given another tablespace is created with data
-    When the user runs "gprecoverseg -ra"
-    Then gprecoverseg should return a return code of 0
-    And the segments are synchronized
-    And the tablespace is valid
-    And the other tablespace is valid
-
-  @concourse_cluster
-  Scenario: recovering a host with tablespaces succeeds
-    Given the database is running
-
-        # Add data including tablespaces
-    And a tablespace is created with data
-    And database "gptest" exists
-    And the user connects to "gptest" with named connection "default"
-    And the user runs psql with "-c 'CREATE TABLE public.before_host_is_down (i int) DISTRIBUTED BY (i)'" against database "gptest"
-    And the user runs psql with "-c 'INSERT INTO public.before_host_is_down SELECT generate_series(1, 10000)'" against database "gptest"
-    And the "public.before_host_is_down" table row count in "gptest" is saved
-
-        # Stop one of the nodes as if for hardware replacement and remove any traces as if it was a new node.
-        # Recoverseg requires the host being restored have the same hostname.
-    And the user runs "gpstop -a --host sdw1"
-    And gpstop should return a return code of 0
-    And the user runs remote command "rm -rf /data/gpdata/*" on host "sdw1"
-    And user can start transactions
-
-        # Add data after one of the nodes is down for maintenance
-    And database "gptest" exists
-    And the user connects to "gptest" with named connection "default"
-    And the user runs psql with "-c 'CREATE TABLE public.after_host_is_down (i int) DISTRIBUTED BY (i)'" against database "gptest"
-    And the user runs psql with "-c 'INSERT INTO public.after_host_is_down SELECT generate_series(1, 10000)'" against database "gptest"
-    And the "public.after_host_is_down" table row count in "gptest" is saved
+        | scenario     | args               |
+        | incremental  | -a                 |
+        | full         | -aF                |
 
-        # restore the down node onto a node with the same hostname
-    When the user runs "gprecoverseg -a -p sdw1"
-    Then gprecoverseg should return a return code of 0
-    And all the segments are running
-    And user can start transactions
-    And the user runs "gprecoverseg -ra"
-    And gprecoverseg should return a return code of 0
-    And all the segments are running
-    And the segments are synchronized
-    And user can start transactions
+      @differential
+      Examples:
+        | scenario     | args               |
+        | differential | -a --differential  |
 
-        # verify the data
-    And the tablespace is valid
-    And the row count from table "public.before_host_is_down" in "gptest" is verified against the saved data
-    And the row count from table "public.after_host_is_down" in "gptest" is verified against the saved data
+    Scenario: gprecoverseg throws exception when -o flag used with invalid flags
+      Given the database is running
+      And all the segments are running
+      And the segments are synchronized
+      When the user runs "gprecoverseg -o output_config -i input_config"
+      Then gprecoverseg should return a return code of 2
+      And gprecoverseg should print "Invalid -i provided with -o argument" to stdout
+      When the user runs "gprecoverseg -o /tmp/output_config -r"
+      Then gprecoverseg should return a return code of 2
+      And gprecoverseg should print "Invalid -r provided with -o argument" to stdout
 
-  @demo_cluster
-  @concourse_cluster
   Scenario: gprecoverseg creates recovery_progress.file in gpAdminLogs
     Given the database is running
     And all files in gpAdminLogs directory are deleted on all hosts in the cluster
@@ -525,14 +596,14 @@ Feature: gprecoverseg tests
     And sql "DROP TABLE IF EXISTS test_recoverseg; CREATE TABLE test_recoverseg AS SELECT generate_series(1,100000000) AS a;" is executed in "postgres" db
     When the user asynchronously runs "gprecoverseg -a" and the process is saved
     Then the user waits until recovery_progress.file is created in gpAdminLogs and verifies its format
-    And an FTS probe is triggered
     And the user waits until saved async process is completed
     And recovery_progress.file should not exist in gpAdminLogs
     And the user waits until mirror on content 0,1,2 is up
     And user can start transactions
     And all files in gpAdminLogs directory are deleted on all hosts in the cluster
     And a sample recovery_progress.file is created from saved lines
-    Then a sample gprecoverseg.lock directory is created in coordinator_data_directory
+    And we run a sample background script to generate a pid on "coordinator" segment
+    Then a sample gprecoverseg.lock directory is created using the background pid in coordinator_data_directory
     When the user runs "gpstate -e"
     Then gpstate should print "Segments in recovery" to stdout
 #    And gpstate output contains "incremental,incremental,incremental" entries for mirrors of content 0,1,2
@@ -542,6 +613,7 @@ Feature: gprecoverseg tests
 #      | \S+     | [0-9]+ | incremental    | [0-9]+                 | [0-9]+             | [0-9]+\%             |
 #      | \S+     | [0-9]+ | incremental    | [0-9]+                 | [0-9]+             | [0-9]+\%             |
     And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And the background pid is killed on "coordinator" segment
     Then the gprecoverseg lock directory is removed
 
     And the cluster is rebalanced
@@ -552,20 +624,14 @@ Feature: gprecoverseg tests
     And the user suspend the walsender on the primary on content 0
     Then the user waits until recovery_progress.file is created in gpAdminLogs and verifies its format
     And verify that lines from recovery_progress.file are present in segment progress files in gpAdminLogs
-
+    When the user runs "gpstate -e"
+    Then gpstate should print "Segments in recovery" to stdout
     And the user reset the walsender on the primary on content 0
     And the user waits until saved async process is completed
     And recovery_progress.file should not exist in gpAdminLogs
-    And an FTS probe is triggered
-    And the user waits until mirror on content 0,1,2 is up
+    And verify that mirror on content 0,1,2 is up
     And user can start transactions
-
-    And a sample recovery_progress.file is created from saved lines
-    Then a sample gprecoverseg.lock directory is created in coordinator_data_directory
-    When the user runs "gpstate -e"
-    Then gpstate should print "Segments in recovery" to stdout
     And all files in gpAdminLogs directory are deleted on all hosts in the cluster
-    Then the gprecoverseg lock directory is removed
 
   @demo_cluster
   @concourse_cluster
@@ -583,7 +649,7 @@ Feature: gprecoverseg tests
     And the user reset the walsender on the primary on content 0
     And the user waits until saved async process is completed
     And recovery_progress.file should not exist in gpAdminLogs
-    And the user waits until mirror on content 0,1,2 is up
+    And verify that mirror on content 0,1,2 is up
     And user can start transactions
     And all files in gpAdminLogs directory are deleted on all hosts in the cluster
 
@@ -602,10 +668,28 @@ Feature: gprecoverseg tests
     And the user reset the walsender on the primary on content 0
     And the user waits until saved async process is completed
     And recovery_progress.file should not exist in /tmp/custom_logdir
-    And the user waits until mirror on content 0,1,2 is up
+    And verify that mirror on content 0,1,2 is up
     And user can start transactions
     And all files in "/tmp/custom_logdir" directory are deleted on all hosts in the cluster
 
+  @demo_cluster
+  @concourse_cluster
+  @differential
+  Scenario: gprecoverseg creates recovery_progress.file in gpAdminLogs for differential recovery of mirrors
+    Given the database is running
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And user immediately stops all mirror processes for content 0,1,2
+    And the user waits until mirror on content 0,1,2 is down
+    And user can start transactions
+    And sql "DROP TABLE IF EXISTS test_recoverseg; CREATE TABLE test_recoverseg AS SELECT generate_series(1,100000000) AS a;" is executed in "postgres" db
+    When the user asynchronously runs "gprecoverseg -a --differential" and the process is saved
+    Then the user waits until recovery_progress.file is created in gpAdminLogs and verifies its format
+    And verify that lines from recovery_progress.file are present in segment progress files in gpAdminLogs
+    And the user waits until saved async process is completed
+    And recovery_progress.file should not exist in gpAdminLogs
+    And verify that mirror on content 0,1,2 is up
+    And user can start transactions
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
 
   @demo_cluster
   @concourse_cluster
@@ -631,11 +715,12 @@ Feature: gprecoverseg tests
     And the user waits until mirror on content 0,1,2 is up
     And the old data directories are cleaned up for content 0
     And user can start transactions
+    And check segment conf: postgresql.conf
     And all files in gpAdminLogs directory are deleted on all hosts in the cluster
 
   @demo_cluster
   @concourse_cluster
-  Scenario:  SIGHUP on gprecoverseg should not display progress in gpstate -e
+  Scenario:  SIGKILL on gprecoverseg should not display progress in gpstate -e
     Given the database is running
     And all the segments are running
     And the segments are synchronized
@@ -649,18 +734,179 @@ Feature: gprecoverseg tests
     Then verify if the gprecoverseg.lock directory is present in coordinator_data_directory
     When the user runs "gpstate -e"
     Then gpstate should print "Segments in recovery" to stdout
-    When the user asynchronously sets up to end gprecoverseg process with SIGHUP
+    When the user asynchronously sets up to end gprecoverseg process with SIGKILL
+    And the user waits until saved async process is completed
+    When the user runs "gpstate -e"
+    Then gpstate should not print "Segments in recovery" to stdout
+    Then the user reset the walsender on the primary on content 0
+    And the user waits until mirror on content 0,1,2 is up
+    And the gprecoverseg lock directory is removed
+    And the cluster is rebalanced
+
+  @demo_cluster
+  @concourse_cluster
+  Scenario: gprecoverseg mixed recovery segments come up even if one basebackup takes longer
+    Given the database is running
+    And all the segments are running
+    And the segments are synchronized
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And user immediately stops all primary processes for content 0,1,2
+    And user can start transactions
+    And the user suspend the walsender on the primary on content 0
+    And sql "DROP TABLE if exists test_recoverseg; CREATE TABLE test_recoverseg AS SELECT generate_series(1,100000000) AS i" is executed in "postgres" db
+    And the "test_recoverseg" table row count in "postgres" is saved
+    And a gprecoverseg directory under '/tmp' with mode '0700' is created
+    And a gprecoverseg input file is created
+    And edit the input file to recover mirror with content 0 full inplace
+    And edit the input file to recover mirror with content 1 full inplace
+    And edit the input file to recover mirror with content 2 incremental
+    When the user asynchronously runs gprecoverseg with input file and additional args "-a" and the process is saved
+    Then the user waits until recovery_progress.file is created in gpAdminLogs and verifies its format
+    And user waits until gp_stat_replication table has no pg_basebackup entries for content 1
+    And the user waits until mirror on content 1,2 is up
+    And verify that mirror on content 0 is down
+    And user can start transactions
+    And verify that lines from recovery_progress.file are present in segment progress files in gpAdminLogs
+    And the user reset the walsender on the primary on content 0
+    And the user waits until saved async process is completed
+    And gpAdminLogs directory has "pg_basebackup*" files on respective hosts only for content 0,1
+    And gpAdminLogs directory has "pg_rewind*" files on respective hosts only for content 2
+    And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
+    And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
+    And the cluster is recovered in full and rebalanced
+    And the row count from table "test_recoverseg" in "postgres" is verified against the saved data
+
+  @demo_cluster
+  Scenario: gprecoverseg should not give warning if pg_basebackup is running for the up segments
+    Given the database is running
+    And all the segments are running
+    And the segments are synchronized
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And user immediately stops all primary processes for content 0,1
+    # Wait for the failover to settle: while FTS is promoting the mirrors for
+    # content 0 and 1, a writer gang can still be built against the descriptors
+    # of the segments that just died, and the next statement fails with "FTS
+    # detected one or more segments are down". The scenario below this one does
+    # the same wait for the same reason.
+    And user can start transactions
+    And the user suspend the walsender on the primary on content 2
+    And the user asynchronously runs pg_basebackup with primary of content 2 as source and the process is saved
+    And an FTS probe is triggered
+    And gp_stat_replication table has pg_basebackup entry for content 2
+    When the user runs "gprecoverseg -avF"
+    Then gprecoverseg should not print "No basebackup running" to stdout
+    And gprecoverseg should return a return code of 0
+    And verify that mirror on content 0,1 is up
+    And gp_stat_replication table has pg_basebackup entry for content 2
+    And the user reset the walsender on the primary on content 2
+    And the user waits until saved async process is completed
+    And verify that mirror on content 2 is up
+    And user can start transactions
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And the cluster is rebalanced
+
+  @demo_cluster
+  @concourse_cluster
+  Scenario: gprecoverseg gives warning if pg_basebackup already running for one of the failed segments
+    Given the database is running
+    And all the segments are running
+    And the segments are synchronized
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And user immediately stops all primary processes for content 0,1,2
+    And user can start transactions
+    And the user suspend the walsender on the primary on content 0
+    And the user asynchronously runs "gprecoverseg -aF" and the process is saved
+    And the user just waits until recovery_progress.file is created in gpAdminLogs
+    And user waits until gp_stat_replication table has no pg_basebackup entries for content 1,2
+    And the user waits until mirror on content 1,2 is up
+    And verify that mirror on content 0 is down
+    And the gprecoverseg lock directory is removed
+    And user immediately stops all primary processes for content 1,2
+    And the user waits until mirror on content 1,2 is down
+    When the user runs "gprecoverseg -avF"
+    Then gprecoverseg should print "Found pg_basebackup running for segments with contentIds [0], skipping recovery of these segments" to logfile
+    And gprecoverseg should return a return code of 0
+    And verify that mirror on content 1,2 is up
+    And verify that mirror on content 0 is down
+    And the user reset the walsender on the primary on content 0
+    And the user waits until saved async process is completed
+    And recovery_progress.file should not exist in gpAdminLogs
+    And verify that mirror on content 0 is up
+    And the user runs "gprecoverseg -avF"
+    Then gprecoverseg should print "No basebackup running" to stdout
+    And gprecoverseg should return a return code of 0
+    And the cluster is rebalanced
+
+  @demo_cluster
+  @concourse_cluster
+  Scenario: gprecoverseg gives warning if pg_basebackup already running for some of the failed segments
+    Given the database is running
+    And all the segments are running
+    And the segments are synchronized
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And user immediately stops all primary processes for content 0,1,2
+    And user can start transactions
+    And the user suspend the walsender on the primary on content 0
+    And the user suspend the walsender on the primary on content 1
+    And the user asynchronously runs "gprecoverseg -aF" and the process is saved
+    And the user just waits until recovery_progress.file is created in gpAdminLogs
+    And user waits until gp_stat_replication table has no pg_basebackup entries for content 2
+    And the user waits until mirror on content 2 is up
+    And verify that mirror on content 0,1 is down
+    And the gprecoverseg lock directory is removed
+    And user immediately stops all primary processes for content 2
+    And the user waits until mirror on content 2 is down
+    When the user runs "gprecoverseg -avF"
+    Then gprecoverseg should print "Found pg_basebackup running for segments with contentIds [0, 1], skipping recovery of these segments" to logfile
+    And gprecoverseg should return a return code of 0
+    And verify that mirror on content 2 is up
+    And verify that mirror on content 0,1 is down
+    And the user reset the walsender on the primary on content 0
+    And the user reset the walsender on the primary on content 1
+    And the user waits until saved async process is completed
+    And recovery_progress.file should not exist in gpAdminLogs
+    And verify that mirror on content 0,1 is up
+    And the user runs "gprecoverseg -avF"
+    Then gprecoverseg should print "No basebackup running" to stdout
+    And gprecoverseg should return a return code of 0
+    And the cluster is rebalanced
+
+  @demo_cluster
+  @concourse_cluster
+  Scenario: gprecoverseg -aF gives warning if pg_basebackup already running for all of the failed segments
+    Given the database is running
+    And all the segments are running
+    And the segments are synchronized
+    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+    And user immediately stops all primary processes for content 0,1,2
+    And user can start transactions
+    And the user suspend the walsender on the primary on content 0
+    And the user suspend the walsender on the primary on content 1
+    And the user suspend the walsender on the primary on content 2
+    And the user asynchronously runs "gprecoverseg -aF" and the process is saved
+    And the user just waits until recovery_progress.file is created in gpAdminLogs
+    And verify that mirror on content 0,1,2 is down
+    And the gprecoverseg lock directory is removed
+    When the user runs "gprecoverseg -aF"
+    Then gprecoverseg should print "Found pg_basebackup running for segments with contentIds [0, 1, 2], skipping recovery of these segments" to logfile
+    And gprecoverseg should print "No segments to recover" to stdout
+    And gprecoverseg should return a return code of 0
+    And verify that mirror on content 0,1,2 is down
+    And the user reset the walsender on the primary on content 0
+    And the user reset the walsender on the primary on content 1
+    And the user reset the walsender on the primary on content 2
     And the user waits until saved async process is completed
-    Then the gprecoverseg lock directory is removed
-    When the user runs "gpstate -e"
-    Then gpstate should not print "Segments in recovery" to stdout
-    Then the user reset the walsender on the primary on content 0
-    And the user waits until mirror on content 0,1,2 is up
+    And recovery_progress.file should not exist in gpAdminLogs
+    And verify that mirror on content 0,1,2 is up
+    And the user runs "gprecoverseg -avF"
+    Then gprecoverseg should print "No basebackup running" to stdout
+    And gprecoverseg should return a return code of 0
+    And verify that mirror on content 0,1,2 is up
     And the cluster is rebalanced
 
   @demo_cluster
   @concourse_cluster
-  Scenario: gprecoverseg mixed recovery segments come up even if one basebackup takes longer
+  Scenario: gprecoverseg -i gives warning if pg_basebackup already running for all failed segments
     Given the database is running
     And all the segments are running
     And the segments are synchronized
@@ -668,29 +914,33 @@ Feature: gprecoverseg tests
     And user immediately stops all primary processes for content 0,1,2
     And user can start transactions
     And the user suspend the walsender on the primary on content 0
-    And sql "DROP TABLE if exists test_recoverseg; CREATE TABLE test_recoverseg AS SELECT generate_series(1,100000000) AS i" is executed in "postgres" db
-    And the "test_recoverseg" table row count in "postgres" is saved
+    And the user suspend the walsender on the primary on content 1
+    And the user suspend the walsender on the primary on content 2
     And a gprecoverseg directory under '/tmp' with mode '0700' is created
     And a gprecoverseg input file is created
     And edit the input file to recover mirror with content 0 full inplace
     And edit the input file to recover mirror with content 1 full inplace
-    And edit the input file to recover mirror with content 2 incremental
+    And edit the input file to recover mirror with content 2 full inplace
     When the user asynchronously runs gprecoverseg with input file and additional args "-a" and the process is saved
-    Then the user waits until recovery_progress.file is created in gpAdminLogs and verifies its format
-    And user waits until gp_stat_replication table has no pg_basebackup entries for content 1
-    And an FTS probe is triggered
-    And the user waits until mirror on content 1,2 is up
-    And verify that mirror on content 0 is down
-    And user can start transactions
-    And verify that lines from recovery_progress.file are present in segment progress files in gpAdminLogs
+    Then the user just waits until recovery_progress.file is created in gpAdminLogs
+    And verify that mirror on content 0,1,2 is down
+    And the gprecoverseg lock directory is removed
+    When the user runs gprecoverseg with input file and additional args "-a"
+    Then gprecoverseg should print "Found pg_basebackup running for segments with contentIds [0, 1, 2], skipping recovery of these segments" to logfile
+    And gprecoverseg should print "No segments to recover" to stdout
+    And gprecoverseg should return a return code of 0
+    And verify that mirror on content 0,1,2 is down
     And the user reset the walsender on the primary on content 0
+    And the user reset the walsender on the primary on content 1
+    And the user reset the walsender on the primary on content 2
     And the user waits until saved async process is completed
-    And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
-    And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
-    And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
-    And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
-    And the cluster is recovered in full and rebalanced
-    And the row count from table "test_recoverseg" in "postgres" is verified against the saved data
+    And recovery_progress.file should not exist in gpAdminLogs
+    And verify that mirror on content 0,1,2 is up
+    And user can start transactions
+    When the user runs gprecoverseg with input file and additional args "-av"
+    Then gprecoverseg should print "No basebackup running" to stdout
+    And gprecoverseg should return a return code of 0
+    Then the cluster is rebalanced
 
   @demo_cluster
   @concourse_cluster
@@ -711,14 +961,14 @@ Feature: gprecoverseg tests
     And check if incremental recovery failed for mirrors with content 0 for gprecoverseg
     And gprecoverseg should print "Failed to recover the following segments. You must run gprecoverseg -F for all incremental failures" to stdout
     And check if incremental recovery was successful for mirrors with content 1,2
-    And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
+    And gpAdminLogs directory has "pg_rewind*" files on all segment hosts
     And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
     And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
 
     And the cluster is recovered in full and rebalanced
     And the row count from table "test_recoverseg" in "postgres" is verified against the saved data
 
-  @demo_cluster
+  @demo_cluster @differential
   Scenario Outline: gprecoverseg differential recovery segments come up even if recovery for one segment fails
     Given the database is running
     And all the segments are running
@@ -736,7 +986,7 @@ Feature: gprecoverseg tests
     And gprecoverseg should print "Failed to recover the following segments. You must run either gprecoverseg --differential or gprecoverseg -F for all differential failures" to stdout
     And verify that mirror on content 1,2 is up
     And the segments are synchronized for content 1,2
-    And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
+    And gpAdminLogs directory has "rsync*" files on all segment hosts
     And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
     And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
     And the temporary directory is removed
@@ -745,184 +995,14 @@ Feature: gprecoverseg tests
 
     Examples:
       | scenario     | args               |
-      | differential | using differential |
       | full         | in full            |
 
-  @concourse_cluster
-    Scenario: Propagating env var
-    Given the database is running
-    And An entry to send SUSPEND_PG_REWIND env var is added on all hosts of cluster
-    And An entry to accept SUSPEND_PG_REWIND env var is added on all hosts of cluster
-
-  @concourse_cluster
-  Scenario: gprecoverseg gives warning if pg_rewind already running for one failed segments
-    Given the database is running
-    And all the segments are running
-    And the segments are synchronized
-    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
-    And user immediately stops all primary processes for content 2
-    And user can start transactions
-    And the environment variable "SUSPEND_PG_REWIND" is set to "600"
-    And the user asynchronously runs "gprecoverseg -a" and the process is saved
-    Then the user just waits until recovery_progress.file is created in gpAdminLogs
-    And verify that mirror on content 2 is down
-    And the gprecoverseg lock directory is removed
-    And user immediately stops all primary processes for content 0,1
-    And the user waits until mirror on content 0,1 is down
-    And an FTS probe is triggered
-    And user can start transactions
-    And "SUSPEND_PG_REWIND" environment variable should be restored
-    When the user runs "gprecoverseg -a"
-    Then gprecoverseg should return a return code of 0
-    And gprecoverseg should print "Found pg_rewind running for segments with contentIds [2], skipping recovery of these segments" to logfile
-    And verify that mirror on content 2 is down
-    And verify that mirror on content 0,1 is up
-    And pg_rewind is killed on mirror with content 2
-    And the user asynchronously sets up to end gprecoverseg process with SIGKILL
-    And the gprecoverseg lock directory is removed
-    And verify that mirror on content 2 is down
-    And the user runs "gprecoverseg -a"
-    And gprecoverseg should return a return code of 0
-    And verify that mirror on content 0,1,2 is up
-    And the cluster is rebalanced
-
-  @concourse_cluster
-  Scenario: gprecoverseg gives warning if pg_rewind already running for some failed segments
-    Given the database is running
-    And all the segments are running
-    And the segments are synchronized
-    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
-    And user immediately stops all primary processes for content 2,3
-    And user can start transactions
-    And the environment variable "SUSPEND_PG_REWIND" is set to "600"
-    And the user asynchronously runs "gprecoverseg -a" and the process is saved
-    Then the user just waits until recovery_progress.file is created in gpAdminLogs
-    And verify that mirror on content 2,3 is down
-    And the gprecoverseg lock directory is removed
-    And user immediately stops all primary processes for content 0,1
-    And the user waits until mirror on content 0,1 is down
-    And an FTS probe is triggered
-    And user can start transactions
-    And "SUSPEND_PG_REWIND" environment variable should be restored
-    When the user runs "gprecoverseg -a"
-    Then gprecoverseg should return a return code of 0
-    And gprecoverseg should print "Found pg_rewind running for segments with contentIds [2, 3], skipping recovery of these segments" to logfile
-    And verify that mirror on content 2,3 is down
-    And verify that mirror on content 0,1 is up
-    And pg_rewind is killed on mirror with content 2,3
-    And the user asynchronously sets up to end gprecoverseg process with SIGKILL
-    And the gprecoverseg lock directory is removed
-    And verify that mirror on content 2,3 is down
-    And the user runs "gprecoverseg -a"
-    And gprecoverseg should return a return code of 0
-    And verify that mirror on content 0,1,2,3 is up
-    And the cluster is rebalanced
-
-  @concourse_cluster
-  Scenario: gprecoverseg gives warning if pg_rewind already running for all failed segments
-    Given the database is running
-    And all the segments are running
-    And the segments are synchronized
-    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
-    And user immediately stops all primary processes for content 0,1,2,3
-    And user can start transactions
-    And the environment variable "SUSPEND_PG_REWIND" is set to "600"
-    And the user asynchronously runs "gprecoverseg -a" and the process is saved
-    Then the user just waits until recovery_progress.file is created in gpAdminLogs
-    And verify that mirror on content 0,1,2,3 is down
-    And the gprecoverseg lock directory is removed
-    And an FTS probe is triggered
-    And user can start transactions
-    When the user runs "gprecoverseg -aF"
-    Then gprecoverseg should return a return code of 0
-    And gprecoverseg should print "Found pg_rewind running for segments with contentIds [0, 1, 2, 3], skipping recovery of these segments" to logfile
-    And verify that mirror on content 0,1,2,3 is down
-    And pg_rewind is killed on mirror with content 0,1,2,3
-    And the user asynchronously sets up to end gprecoverseg process with SIGKILL
-    And the gprecoverseg lock directory is removed
-    And verify that mirror on content 0,1,2,3 is down
-    And "SUSPEND_PG_REWIND" environment variable should be restored
-    And the user runs "gprecoverseg -a"
-    And gprecoverseg should return a return code of 0
-    And verify that mirror on content 0,1,2,3 is up
-    And the cluster is rebalanced
-
-  @concourse_cluster
-  Scenario: gprecoverseg -i gives warning if pg_rewind already running for some of the failed segments
-    Given the database is running
-    And all the segments are running
-    And the segments are synchronized
-    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
-    And user immediately stops all primary processes for content 0,1
-    And user can start transactions
-    And the environment variable "SUSPEND_PG_REWIND" is set to "600"
-    And the user asynchronously runs "gprecoverseg -a" and the process is saved
-    And the user just waits until recovery_progress.file is created in gpAdminLogs
-    And verify that mirror on content 0,1 is down
-    And the gprecoverseg lock directory is removed
-    And user immediately stops all primary processes for content 2,3
-    And the user waits until mirror on content 2,3 is down
-    And an FTS probe is triggered
-    And user can start transactions
-    Then "SUSPEND_PG_REWIND" environment variable should be restored
-    Given a gprecoverseg directory under '/tmp' with mode '0700' is created
-    And a gprecoverseg input file is created
-    And edit the input file to recover mirror with content 0 full inplace
-    And edit the input file to recover mirror with content 1 incremental
-    And edit the input file to recover mirror with content 2 incremental
-    And edit the input file to recover mirror with content 3 incremental
-    When the user runs gprecoverseg with input file and additional args "-a"
-    Then gprecoverseg should return a return code of 0
-    And gprecoverseg should print "Found pg_rewind running for segments with contentIds [0, 1], skipping recovery of these segments" to logfile
-    And verify that mirror on content 2,3 is up
-    And verify that mirror on content 0,1 is down
-    And pg_rewind is killed on mirror with content 0,1
-    And the user asynchronously sets up to end gprecoverseg process with SIGKILL
-    And the gprecoverseg lock directory is removed
-    And verify that mirror on content 0,1 is down
-    And the user runs "gprecoverseg -a"
-    And gprecoverseg should return a return code of 0
-    And verify that mirror on content 0,1,2 is up
-    And the cluster is rebalanced
+    @differential
+    Examples:
+      | scenario     | args               |
+      | differential | using differential |
 
-  @concourse_cluster
-  Scenario: gprecoverseg -i gives warning if pg_rewind already running for all of the failed segments
-    Given the database is running
-    And all the segments are running
-    And the segments are synchronized
-    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
-    And user immediately stops all primary processes for content 0,1,2,3
-    And user can start transactions
-    And the environment variable "SUSPEND_PG_REWIND" is set to "600"
-    And the user asynchronously runs "gprecoverseg -a" and the process is saved
-    And the user just waits until recovery_progress.file is created in gpAdminLogs
-    And verify that mirror on content 0,1,2,3 is down
-    And the gprecoverseg lock directory is removed
-    And an FTS probe is triggered
-    And user can start transactions
-    Given a gprecoverseg directory under '/tmp' with mode '0700' is created
-    And a gprecoverseg input file is created
-    And edit the input file to recover mirror with content 0 full inplace
-    And edit the input file to recover mirror with content 1 full inplace
-    And edit the input file to recover mirror with content 2 incremental
-    And edit the input file to recover mirror with content 3 incremental
-    When the user runs gprecoverseg with input file and additional args "-a"
-    Then gprecoverseg should return a return code of 0
-    And gprecoverseg should print "Found pg_rewind running for segments with contentIds [0, 1, 2, 3], skipping recovery of these segments" to logfile
-    And verify that mirror on content 0,1,2,3 is down
-    And pg_rewind is killed on mirror with content 0,1,2,3
-    And the user asynchronously sets up to end gprecoverseg process with SIGKILL
-    And the gprecoverseg lock directory is removed
-    And verify that mirror on content 0,1,2,3 is down
-    Then "SUSPEND_PG_REWIND" environment variable should be restored
-    And the user runs "gprecoverseg -a"
-    And gprecoverseg should return a return code of 0
-    And verify that mirror on content 0,1,2,3 is up
-    And the cluster is rebalanced
-    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
 
-  @demo_cluster
-  @concourse_cluster
   Scenario: gprecoverseg mixed recovery one basebackup fails and one rewind fails while others succeed
     Given the database is running
     And all the segments are running
@@ -944,69 +1024,27 @@ Feature: gprecoverseg tests
     When the user runs gprecoverseg with input file and additional args "-a"
     Then gprecoverseg should return a return code of 1
     And user can start transactions
+    And check segment conf: postgresql.conf
+
 
     And check if incremental recovery failed for mirrors with content 0 for gprecoverseg
     And check if full recovery was successful for mirrors with content 1
     And check if full recovery failed for mirrors with content 2 for gprecoverseg
+    And gprecoverseg should print "error:.*required WAL directory ""pg_wal"" does not exist" to stdout
+    And gprecoverseg should print "error: pg_basebackup: error: could not access directory.* Permission denied" to stdout
     And gprecoverseg should not print "Segments successfully recovered" to stdout
     And check if mirrors on content 0,1,2 are in their original configuration
     And the gp_configuration_history table should contain a backout entry for the primary segment for contents 2
 
     And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
     And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
+    And check segment conf: postgresql.conf
 
     And the mode of all the created data directories is changed to 0700
     And the cluster is recovered in full and rebalanced
+    And check segment conf: postgresql.conf
     And the row count from table "test_recoverseg" in "postgres" is verified against the saved data
 
-  @demo_cluster
-  @concourse_cluster
-  Scenario: gprecoverseg mixed recovery segments come up even if one pg_ctl_start fails
-    Given the database is running
-    And all the segments are running
-    And the segments are synchronized
-    And all files in gpAdminLogs directory are deleted on all hosts in the cluster
-    And the information of contents 0,1,2 is saved
-    And user immediately stops all primary processes for content 0,1,2
-    And user can start transactions
-
-    And sql "DROP TABLE if exists test_recoverseg; CREATE TABLE test_recoverseg AS SELECT generate_series(1,10000) AS i" is executed in "postgres" db
-    And the "test_recoverseg" table row count in "postgres" is saved
-
-    And a gprecoverseg directory under '/tmp' with mode '0700' is created
-    And a gprecoverseg input file is created
-    And edit the input file to recover mirror with content 0 to a new directory on remote host with mode 0755
-    And edit the input file to recover mirror with content 1 full inplace
-    And edit the input file to recover mirror with content 2 incremental
-
-    When the user runs gprecoverseg with input file and additional args "-a"
-    Then gprecoverseg should return a return code of 1
-    And user can start transactions
-    And verify that mirror on content 0 is down
-    And verify that mirror on content 1,2 is up
-
-    And check if start failed for contents 0 during full recovery for gprecoverseg
-    And check if full recovery was successful for mirrors with content 1
-    And check if incremental recovery was successful for mirrors with content 2
-    And check if mirrors on content 0 are moved to new location on input file
-    And check if mirrors on content 1,2 are in their original configuration
-    And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
-    And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
-    And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
-    And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
-    And verify there are no recovery backout files
-    And the old data directories are cleaned up for content 0
-
-    And the mode of all the created data directories is changed to 0700
-    Then the user runs "gprecoverseg -a"
-    And gprecoverseg should return a return code of 0
-    And user can start transactions
-    And the segments are synchronized
-    And the cluster is rebalanced
-    And the row count from table "test_recoverseg" in "postgres" is verified against the saved data
-
-  @demo_cluster
-  @concourse_cluster
   Scenario: gprecoverseg mixed recovery segments come up even if all pg_ctl_start fails
     Given the database is running
     And all the segments are running
@@ -1035,8 +1073,7 @@ Feature: gprecoverseg tests
     And verify that mirror on content 0,1,2 is down
 
     And check if mirrors on content 0,1,2 are moved to new location on input file
-    And gpAdminLogs directory has no "pg_basebackup*" files on all segment hosts
-    And gpAdminLogs directory has no "pg_rewind*" files on all segment hosts
+    And gpAdminLogs directory has "pg_basebackup*" files on all segment hosts
     And gpAdminLogs directory has "gpsegsetuprecovery*" files on all segment hosts
     And gpAdminLogs directory has "gpsegrecovery*" files on all segment hosts
     And verify there are no recovery backout files
@@ -1047,16 +1084,17 @@ Feature: gprecoverseg tests
     And user can start transactions
     And the segments are synchronized
     And the cluster is rebalanced
+    And check segment conf: postgresql.conf
     And the row count from table "test_recoverseg" in "postgres" is verified against the saved data
 
-  @concourse_cluster
+    @concourse_cluster
     Scenario: gprecoverseg behave test requires a cluster with at least 2 hosts
         Given the database is running
         Given database "gptest" exists
         And the information of a "mirror" segment on a remote host is saved
 
     @concourse_cluster
-    Scenario: When gprecoverseg full recovery is executed and an existing postmaster.pid on the killed primary segment corresponds to a non postgres process
+    Scenario Outline: When gprecoverseg <scenario> recovery is executed and an existing postmaster.pid on the killed primary segment corresponds to a non postgres process
         Given the database is running
         And all the segments are running
         And the segments are synchronized
@@ -1066,7 +1104,7 @@ Feature: gprecoverseg tests
         When user can start transactions
         And we run a sample background script to generate a pid on "primary" segment
         And we generate the postmaster.pid file with the background pid on "primary" segment
-        And the user runs "gprecoverseg -F -a"
+        And the user runs "gprecoverseg <args>"
         Then gprecoverseg should return a return code of 0
         And gprecoverseg should not print "Unhandled exception in thread started by <bound method Worker.__bootstrap" to stdout
         And gprecoverseg should print "Skipping to stop segment.* on host.* since it is not a postgres process" to stdout
@@ -1079,6 +1117,15 @@ Feature: gprecoverseg tests
         And the backup pid file is deleted on "primary" segment
         And the background pid is killed on "primary" segment
 
+      Examples:
+        | scenario     | args               |
+        | full         | -aF                |
+
+      @differential
+      Examples:
+        | scenario     | args               |
+        | differential | -a --differential  |
+
     @concourse_cluster
     Scenario: gprecoverseg full recovery testing
         Given the database is running
@@ -1095,6 +1142,7 @@ Feature: gprecoverseg tests
         And gprecoverseg should print "Segments successfully recovered" to stdout
         And all the segments are running
         And the segments are synchronized
+        And check segment conf: postgresql.conf
 
     @concourse_cluster
     Scenario: gprecoverseg with -i and -o option
@@ -1154,6 +1202,29 @@ Feature: gprecoverseg tests
         # validate the new segment has the correct setting by getting admin connection to that segment
         Then the saved primary segment reports the same value for sql "show data_checksums" db "template1" as was saved
 
+    @concourse_cluster
+    @differential
+    Scenario: gprecoverseg should use the same setting for data_checksums for a differential recovery
+        Given the database is running
+        And results of the sql "show data_checksums" db "template1" are stored in the context
+        And all the segments are running
+        And the segments are synchronized
+        And the information of a "mirror" segment on a remote host is saved
+        And the information of the corresponding primary segment on a remote host is saved
+        When user kills a "primary" process with the saved information
+        And user can start transactions
+        Then the saved "primary" segment is marked down in config
+        When the user runs "gprecoverseg --differential -a"
+        Then gprecoverseg should return a return code of 0
+        And gprecoverseg should print "Heap checksum setting is consistent between coordinator and the segments that are candidates for recoverseg" to stdout
+        When the user runs "gprecoverseg -ra"
+        Then gprecoverseg should return a return code of 0
+        And gprecoverseg should print "Heap checksum setting is consistent between coordinator and the segments that are candidates for recoverseg" to stdout
+        And all the segments are running
+        And the segments are synchronized
+        And verify replication slot internal_wal_replication_slot is available on all the segments
+        Then the saved primary segment reports the same value for sql "show data_checksums" db "template1" as was saved
+
   @concourse_cluster
   Scenario: moving mirror to a different host must work
       Given the database is running
@@ -1164,7 +1235,7 @@ Feature: gprecoverseg tests
        When user kills a "mirror" process with the saved information
         And user can start transactions
        Then the saved "mirror" segment is marked down in config
-       When the user runs "gprecoverseg -a -p mdw"
+       When the user runs "gprecoverseg -a -p cdw"
        Then gprecoverseg should return a return code of 0
        When user kills a "primary" process with the saved information
         And user can start transactions
@@ -1177,6 +1248,7 @@ Feature: gprecoverseg tests
        Then gprecoverseg should return a return code of 0
         And all the segments are running
         And the segments are synchronized
+        And check segment conf: postgresql.conf
 
     @concourse_cluster
     Scenario: gprecoverseg does not create backout scripts if a segment recovery fails before the catalog is changed
@@ -1200,6 +1272,7 @@ Feature: gprecoverseg tests
          Then gprecoverseg should return a return code of 0
           And all the segments are running
           And the segments are synchronized
+          And check segment conf: postgresql.conf
 
 
     @concourse_cluster
@@ -1209,7 +1282,7 @@ Feature: gprecoverseg tests
       And all the segments are running
       And the segments are synchronized
       And the information of contents 0,1,2 is saved
-      And all files in gpAdminLogs directory are deleted on hosts mdw,sdw1,sdw2
+      And all files in gpAdminLogs directory are deleted on hosts cdw,sdw1,sdw2
       And the "primary" segment information is saved
 
       And the primary on content 0 is stopped
@@ -1235,6 +1308,7 @@ Feature: gprecoverseg tests
       And all the segments are running
       And the segments are synchronized
       Then the cluster is rebalanced
+      And check segment conf: postgresql.conf
 
   @demo_cluster
   @concourse_cluster
@@ -1276,6 +1350,7 @@ Feature: gprecoverseg tests
     And all the segments are running
     And the segments are synchronized
     And the cluster is rebalanced
+    And check segment conf: postgresql.conf
 
   @demo_cluster
   @concourse_cluster
@@ -1309,12 +1384,13 @@ Feature: gprecoverseg tests
     And the gp_configuration_history table should contain a backout entry for the primary segment for contents 0,1
 
     And the mode of all the created data directories is changed to 0700
-    When the user runs "gprecoverseg -a"
+    When the user runs "gprecoverseg -aF"
     Then gprecoverseg should return a return code of 0
     And user can start transactions
     And all the segments are running
     And the segments are synchronized
     And the cluster is rebalanced
+    And check segment conf: postgresql.conf
 
     @concourse_cluster
     Scenario: gprecoverseg cleans up backout scripts upon successful segment recovery
@@ -1463,6 +1539,7 @@ Feature: gprecoverseg tests
 
   @demo_cluster
   @concourse_cluster
+  @differential
   Scenario: gprecoverseg should terminate gracefully on SIGTERM when running differential recovery
     Given the database is running
     And all the segments are running
@@ -1850,3 +1927,44 @@ Feature: gprecoverseg tests
     And the user runs "gprecoverseg -a -v"
     Then gprecoverseg should return a return code of 0
     And the cluster is rebalanced
+
+  @demo_cluster
+  @concourse_cluster
+  Scenario: gprecoverseg rebalance aborts and throws exception if replay lag on mirror is more than or equal to the allowed limit
+      Given the database is running
+        And all the segments are running
+        And the segments are synchronized
+        And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+        And user immediately stops all primary processes for content 0
+        And user can start transactions
+        When the user runs "gprecoverseg -av"
+        Then gprecoverseg should return a return code of 0
+        When the user runs "gprecoverseg -ar --replay-lag 0"
+        Then gprecoverseg should return a return code of 2
+         And gprecoverseg should print "0 bytes of wal is still to be replayed on mirror with dbid.*, let mirror catchup on replay then trigger rebalance" regex to logfile
+        When the user runs "gprecoverseg -ar --disable-replay-lag"
+        Then gprecoverseg should return a return code of 0
+         And all the segments are running
+         And user can start transactions
+
+  @demo_cluster
+  @concourse_cluster
+  Scenario: gprecoverseg errors out if invalid options are used with --disable-replay-lag
+      Given the database is running
+        And all the segments are running
+        And the segments are synchronized
+        And all files in gpAdminLogs directory are deleted on all hosts in the cluster
+        And user immediately stops all primary processes for content 0,1,2
+        And user can start transactions
+       When the user runs "gprecoverseg -av"
+       Then gprecoverseg should return a return code of 0
+        And verify that mirror on content 0,1,2 is up
+       When the user runs "gprecoverseg -aF --disable-replay-lag"
+       Then gprecoverseg should return a return code of 2
+        And gprecoverseg should print "--disable-replay-lag should be used only with -r" to stdout
+       When the user runs "gprecoverseg -ar"
+       Then gprecoverseg should return a return code of 0
+        And gprecoverseg should print "Allowed replay lag during rebalance is 10 GB" to stdout
+        And all the segments are running
+        And user can start transactions
+
diff --git a/gpMgmt/test/behave/mgmt_utils/gpssh.feature b/gpMgmt/test/behave/mgmt_utils/gpssh.feature
index 07d7736db56..08aa48b3ef5 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpssh.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpssh.feature
@@ -24,10 +24,11 @@ Feature: gpssh behave tests
         And gpssh should print "unable to login to localhost" to stdout
         And gpssh should print "could not synchronize with original prompt" to stdout
 
+    @requires_netem
     Scenario: gpssh succeeds when network has latency
         When the user runs command "sudo tc qdisc add dev lo root netem delay 4000ms"
         Then sudo should return a return code of 0
         When the user runs "gpssh -h localhost echo 'hello I am testing'"
         Then gpssh should return a return code of 0
         And gpssh should print "hello I am testing" to stdout
-        # We depend on environment.py#after_scenario() to delete the artificial latency
\ No newline at end of file
+        # We depend on environment.py#after_scenario() to delete the artificial latency
diff --git a/gpMgmt/test/behave/mgmt_utils/gpstart.feature b/gpMgmt/test/behave/mgmt_utils/gpstart.feature
index 4635547c3c1..e90af41b56c 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpstart.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpstart.feature
@@ -57,10 +57,11 @@ Feature: gpstart behave tests
 
     @concourse_cluster
     @demo_cluster
-    Scenario: gpstart starts even if a segment host is unreachable
+    Scenario: gpstart starts even if a segment host is unreachable and mirror is promoted
         Given the database is running
-          And the host for the primary on content 0 is made unreachable
-          And the host for the mirror on content 1 is made unreachable
+          And fts probing is disabled
+          And the host for the primary on content 0 is made unreachable and do not wait for failover
+          And the host for the mirror on content 1 is made unreachable and do not wait for failover
 
           And the user runs command "pkill -9 postgres" on all hosts without validation
          When "gpstart" is run with prompts accepted
@@ -69,6 +70,7 @@ Feature: gpstart behave tests
           And gpstart should print unreachable host messages for the down segments
           And the status of the primary on content 0 should be "d"
           And the status of the mirror on content 1 should be "d"
+          And the role of the mirror on content 0 should be "p"
           And the cluster is returned to a good state
 
     @concourse_cluster
@@ -103,11 +105,6 @@ Feature: gpstart behave tests
          | non-super user connections | False                   | -U foouser -c '\l'   |
 
 
-    # NOTE: On GP-7x, There are couple of open bugs existing for utility mode connections (gpstart -m & gpstart -mR)
-    # https://github.com/greenplum-db/gpdb/issues/12217 : "gpstart -m" accepts connections without checking "gp_role=utility"
-    # https://github.com/greenplum-db/gpdb/issues/12566 :  Non-superuser should not be able to connect via utility mode
-
-    # Expected result of below test cases might change based on above issues fix
     @concourse_cluster
     @demo_cluster
     Scenario Outline: "gpstart -m" accepts <test_scenarios> when utility mode is set to <utility_mode>
@@ -125,8 +122,25 @@ Feature: gpstart behave tests
          | test_scenarios             | utility_mode            | psql_cmd             |
          | super user connections     | True                    | -c '\l'              |
          | non-super user connections | True                    | -U foouser -c '\l'   |
-         | super user connections     | False                   | -c '\l'              |
-         | non-super user connections | False                   | -U foouser -c '\l'   |
+
+    @concourse_cluster
+    @demo_cluster
+    Scenario Outline: "gpstart -m" accepts <test_scenarios> when utility mode is set to <utility_mode>
+        Given the database is not running
+          And the user runs "gpstart -ma"
+          And "gpstart -ma" should return a return code of 0
+
+         When The user runs psql "<psql_cmd>" against database "postgres" when utility mode is set to "<utility_mode>"
+         Then psql_cmd should return a return code of <return_code>
+          And psql_cmd should print "<error_msg>" error message
+
+          And the user runs "gpstop -mai"
+          And "gpstop -mai" should return a return code of 0
+
+     Examples:
+         | test_scenarios             | utility_mode            | psql_cmd             | return_code | error_msg                                                                                                                     |
+         | super user connections     | False                   | -c '\l'              | 2           | psql: error: FATAL:  System was started in single node mode - only utility mode connections are allowed          |
+         | non-super user connections | False                   | -U foouser -c '\l'   | 2           | psql: error: FATAL:  System was started in single node mode - only utility mode connections are allowed          |
 
     @concourse_cluster
     @demo_cluster
@@ -143,11 +157,11 @@ Feature: gpstart behave tests
           And "gpstop -mai" should return a return code of 0
 
       Examples:
-         | test_scenarios             | utility_mode            | psql_cmd             | return_code | database      | error_out_state | error_msg                                                                                                       |
-         | super user connections     | True                    | -c '\l'              | 0           | accepts       | should not      | psql: error: FATAL:  remaining connection slots are reserved for non-replication superuser connections          |
-         | non-super user connections | True                    | -U foouser -c '\l'   | 2           | rejects       | should          | psql: error: FATAL:  remaining connection slots are reserved for non-replication superuser connections          |
-         | super user connections     | False                   | -c '\l'              | 0           | accepts       | should not      | psql: error: FATAL:  remaining connection slots are reserved for non-replication superuser connections          |
-         | non-super user connections | False                   | -U foouser -c '\l'   | 2           | rejects       | should          | psql: error: FATAL:  remaining connection slots are reserved for non-replication superuser connections          |
+         | test_scenarios             | utility_mode            | psql_cmd             | return_code | database      | error_out_state | error_msg                                                                                                                     |
+         | super user connections     | True                    | -c '\l'              | 0           | accepts       | should not      | psql: error: FATAL:  remaining connection slots are reserved for non-replication superuser connections                        |
+         | non-super user connections | True                    | -U foouser -c '\l'   | 2           | rejects       | should          | psql: error: FATAL:  remaining connection slots are reserved for non-replication superuser connections                        |
+         | super user connections     | False                   | -c '\l'              | 2           | accepts       | should          | psql: error: FATAL:  System was started in single node mode - only utility mode connections are allowed          |
+         | non-super user connections | False                   | -U foouser -c '\l'   | 2           | rejects       | should          | psql: error: FATAL:  System was started in single node mode - only utility mode connections are allowed          |
 
     @concourse_cluster
     @demo_cluster
@@ -187,5 +201,3 @@ Feature: gpstart behave tests
          When the user runs "gpstart -a -B 1"
          Then "gpstart -a -B 1" should return a return code of 0
           And gpcheckcat should not print "Number of segments which failed to start:.*" to stdout
-
-
diff --git a/gpMgmt/test/behave/mgmt_utils/gpstate.feature b/gpMgmt/test/behave/mgmt_utils/gpstate.feature
index e03c7f7bd8e..afd1ce37676 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpstate.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpstate.feature
@@ -160,7 +160,8 @@ Feature: gpstate tests
         Given a standard local demo cluster is running
         Given all files in gpAdminLogs directory are deleted
         And a sample recovery_progress.file is created with ongoing recoveries in gpAdminLogs
-        And a sample gprecoverseg.lock directory is created in coordinator_data_directory
+        And we run a sample background script to generate a pid on "coordinator" segment
+        And a sample gprecoverseg.lock directory is created using the background pid in coordinator_data_directory
         When the user runs "gpstate -e"
         Then gpstate should print "Segments in recovery" to stdout
         And gpstate output contains "full,incremental" entries for mirrors of content 0,1
@@ -169,13 +170,15 @@ Feature: gpstate tests
             | \S+     | [0-9]+ | full           | 1164848                | 1371715            | 84%                  |
             | \S+     | [0-9]+ | incremental    | 1                      | 1371875            | 1%                   |
         And all files in gpAdminLogs directory are deleted
+        And the background pid is killed on "coordinator" segment
         And the gprecoverseg lock directory is removed
 
     Scenario: gpstate -e does not show information about segments with completed recovery
         Given a standard local demo cluster is running
         Given all files in gpAdminLogs directory are deleted
         And a sample recovery_progress.file is created with completed recoveries in gpAdminLogs
-        And a sample gprecoverseg.lock directory is created in coordinator_data_directory
+        And we run a sample background script to generate a pid on "coordinator" segment
+        And a sample gprecoverseg.lock directory is created using the background pid in coordinator_data_directory
         When the user runs "gpstate -e"
         Then gpstate should print "Segments in recovery" to stdout
         And gpstate output contains "full" entries for mirrors of content 1
@@ -185,6 +188,7 @@ Feature: gpstate tests
         And gpstate should not print "incremental" to stdout
         And gpstate should not print "All segments are running normally" to stdout
         And all files in gpAdminLogs directory are deleted
+        And the background pid is killed on "coordinator" segment
         Then the gprecoverseg lock directory is removed
 
     Scenario: gpstate -c logs cluster info for a mirrored cluster
@@ -251,7 +255,7 @@ Feature: gpstate tests
     Scenario: gpstate -m logs mirror details
         Given a standard local demo cluster is running
         When the user runs "gpstate -m"
-        Then gpstate should print "Current GPDB mirror list and status" to stdout
+        Then gpstate should print "Current CBDB mirror list and status" to stdout
         And gpstate output looks like
             | Mirror | Datadir                        | Port   | Status  | Data Status  |
             | \S+    | .*/dbfast_mirror1/demoDataDir0 | [0-9]+ | Passive | Synchronized |
@@ -263,7 +267,7 @@ Feature: gpstate tests
           And user stops all primary processes
           And user can start transactions
         When the user runs "gpstate -m"
-        Then gpstate should print "Current GPDB mirror list and status" to stdout
+        Then gpstate should print "Current CBDB mirror list and status" to stdout
         And gpstate output looks like
             | Mirror | Datadir                        | Port   | Status            | Data Status |
             | \S+    | .*/dbfast_mirror1/demoDataDir0 | [0-9]+ | Acting as Primary | Not In Sync |
diff --git a/gpMgmt/test/behave/mgmt_utils/gpstop.feature b/gpMgmt/test/behave/mgmt_utils/gpstop.feature
index aed47ea7103..c259cae535c 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpstop.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpstop.feature
@@ -5,8 +5,10 @@ Feature: gpstop behave tests
     @demo_cluster
     Scenario: gpstop succeeds
         Given the database is running
+          And running postgres processes are saved in context
          When the user runs "gpstop -a"
          Then gpstop should return a return code of 0
+         And verify no postgres process is running on all hosts
 
     @demo_cluster
     Scenario: gpstop runs with given coordinator data directory option
@@ -33,20 +35,24 @@ Feature: gpstop behave tests
     Scenario: when there are user connections gpstop waits to shutdown until user switches to fast mode
         Given the database is running
           And the user asynchronously runs "psql postgres" and the process is saved
+          And running postgres processes are saved in context
          When the user runs gpstop -a -t 4 --skipvalidation and selects f
           And gpstop should print "'\(s\)mart_mode', '\(f\)ast_mode', '\(i\)mmediate_mode'" to stdout
          Then gpstop should return a return code of 0
+         And verify no postgres process is running on all hosts
 
     @concourse_cluster
     @demo_cluster
     Scenario: when there are user connections gpstop waits to shutdown until user connections are disconnected
         Given the database is running
           And the user asynchronously runs "psql postgres" and the process is saved
-          And the user asynchronously sets up to end that process in 6 seconds
+          And the user asynchronously sets up to end that process in 15 seconds
+          And running postgres processes are saved in context
          When the user runs gpstop -a -t 2 --skipvalidation and selects s
           And gpstop should print "There were 1 user connections at the start of the shutdown" to stdout
           And gpstop should print "'\(s\)mart_mode', '\(f\)ast_mode', '\(i\)mmediate_mode'" to stdout
          Then gpstop should return a return code of 0
+         And verify no postgres process is running on all hosts
 
     @demo_cluster
     Scenario: gpstop succeeds even if the standby host is unreachable
@@ -58,8 +64,39 @@ Feature: gpstop behave tests
           And gpstop should return a return code of 0
           And the standby host is made reachable
 
-    @concourse_cluster
     @demo_cluster
+    Scenario: gpstop succeeds when pg_ctl command fails
+        Given the database is running
+          And the user runs psql with "-c "CREATE EXTENSION IF NOT EXISTS gp_inject_fault;"" against database "postgres"
+          And the user runs psql with "-c "SELECT gp_inject_fault('checkpoint', 'sleep', '', '', '', 1, -1, 3600, dbid) FROM gp_segment_configuration WHERE content = -1 AND role = 'p'"" against database "postgres"
+          And running postgres processes are saved in context
+         When the user runs "gpstop -a -M fast"
+          And gpstop should print "Failed to shutdown coordinator with pg_ctl." to stdout
+          And gpstop should return a return code of 0
+          And verify no postgres process is running on all hosts
+
+    @demo_cluster
+    Scenario: gpstop succeeds with immediate option
+        Given the database is running
+          And the user asynchronously runs "psql postgres" and the process is saved
+          And the user asynchronously sets up to end that process in 15 seconds
+          And running postgres processes are saved in context
+         When the user runs "gpstop -a -M immediate"
+          And gpstop should print "Commencing Coordinator instance shutdown with mode='immediate'" to stdout
+         Then gpstop should return a return code of 0
+          And verify no postgres process is running on all hosts
+
+    Scenario: gpstop fails when the lock file is already held by another gpstop process
+        Given the database is running
+        And we run a sample background script to generate a pid on "coordinator" segment
+        Then a sample gpstop.lock directory is created using the background pid in coordinator_data_directory
+        And the user runs "gpstop -a"
+        And gpstop should print "gpstop.lock indicates that an instance of gpstop is already running" to stdout
+        # proceeding graceful shutdown of the database.
+        And the background pid is killed on "coordinator" segment
+        And the user runs gpstop -a and selects f
+        And gpstop should return a return code of 0
+
     Scenario: gpstop removes the lock directory when it is empty
         Given the database is running
         Then a sample gpstop.lock directory is created using the background pid in coordinator_data_directory
diff --git a/gpMgmt/test/behave/mgmt_utils/minirepro.feature b/gpMgmt/test/behave/mgmt_utils/minirepro.feature
index 15e9c666a51..ba5ad4e5bf8 100644
--- a/gpMgmt/test/behave/mgmt_utils/minirepro.feature
+++ b/gpMgmt/test/behave/mgmt_utils/minirepro.feature
@@ -28,7 +28,9 @@ Feature: Dump minimum database objects that is related to the query
     @minirepro_UI
     Scenario: Database does not exist
       Given database "nonedb000" does not exist
-      When the user runs "minirepro nonedb000 -q ~/test/in.sql -f ~/out.sql"
+      # Make sure that minirepro doesn't complains about the missing of in.sql.
+      Given the file "/tmp/in.sql" exists and contains "select 1;"
+      When the user runs "minirepro nonedb000 -q /tmp/in.sql -f ~/out.sql"
       Then minirepro error should contain database "nonedb000" does not exist
 
     @minirepro_core
@@ -43,8 +45,8 @@ Feature: Dump minimum database objects that is related to the query
       Given the file "/tmp/in.sql" exists and contains "select * from t1; delete from t2;"
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t1"
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t2"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t1"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t2"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't1'"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't2'"
       And the output file "/tmp/out.sql" should be loaded to database "minidb_tmp" without error
@@ -62,9 +64,9 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t1" before "CREATE TABLE t3"
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3" before "CREATE VIEW v1"
-      And the output file "/tmp/out.sql" should not contain "CREATE TABLE t2"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t1" before "CREATE TABLE public.t3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3" before "CREATE VIEW public.v1"
+      And the output file "/tmp/out.sql" should not contain "CREATE TABLE public.t2"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't1'"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't3'"
       And the output file "/tmp/out.sql" should contain "Table: t1, Attribute: a"
@@ -80,12 +82,12 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t1" before "CREATE TABLE t3"
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3" before "CREATE VIEW v1"
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t2" before "CREATE TABLE t3"
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3" before "CREATE VIEW v2"
-      And the output file "/tmp/out.sql" should contain "CREATE VIEW v1" before "CREATE VIEW v3"
-      And the output file "/tmp/out.sql" should contain "CREATE VIEW v2" before "CREATE VIEW v3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t1" before "CREATE TABLE public.t3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3" before "CREATE VIEW public.v1"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t2" before "CREATE TABLE public.t3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3" before "CREATE VIEW public.v2"
+      And the output file "/tmp/out.sql" should contain "CREATE VIEW public.v1" before "CREATE VIEW public.v3"
+      And the output file "/tmp/out.sql" should contain "CREATE VIEW public.v2" before "CREATE VIEW public.v3"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't1'"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't2'"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't3'"
@@ -104,7 +106,7 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t1"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t1"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't1'"
       And the output file "/tmp/out.sql" should contain "Table: t1, Attribute: a"
       And the output file "/tmp/out.sql" should contain "Table: t1, Attribute: b"
@@ -117,7 +119,7 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t2"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t2"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't2'"
       And the output file "/tmp/out.sql" should contain "Table: t2, Attribute: c"
       And the output file "/tmp/out.sql" should contain "Table: t2, Attribute: d"
@@ -130,7 +132,7 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't3'"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: e"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: f"
@@ -143,7 +145,7 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should not contain "CREATE TABLE t0"
+      And the output file "/tmp/out.sql" should not contain "CREATE TABLE public.t0"
       And the output file "/tmp/out.sql" should be loaded to database "minidb_tmp" without error
       And the file "/tmp/in.sql" should be executed in database "minidb_tmp" without error
 
@@ -153,8 +155,8 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should not contain "CREATE TABLE t0"
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3"
+      And the output file "/tmp/out.sql" should not contain "CREATE TABLE public.t0"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't3'"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: e"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: f"
@@ -167,7 +169,7 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t2"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t2"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't2'"
       And the output file "/tmp/out.sql" should contain "Table: t2, Attribute: c"
       And the output file "/tmp/out.sql" should contain "Table: t2, Attribute: d"
@@ -180,7 +182,7 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t1"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t1"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't1'"
       And the output file "/tmp/out.sql" should contain "Table: t1, Attribute: a"
       And the output file "/tmp/out.sql" should contain "Table: t1, Attribute: b"
@@ -193,7 +195,7 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't3'"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: e"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: f"
@@ -206,9 +208,9 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t2" before "CREATE TABLE t3"
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3" before "CREATE VIEW v2"
-      And the output file "/tmp/out.sql" should not contain "CREATE TABLE t1"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t2" before "CREATE TABLE public.t3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3" before "CREATE VIEW public.v2"
+      And the output file "/tmp/out.sql" should not contain "CREATE TABLE public.t1"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't2'"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't3'"
       And the output file "/tmp/out.sql" should contain "Table: t2, Attribute: c"
@@ -244,7 +246,7 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't3'"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: e"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: f"
@@ -257,9 +259,33 @@ Feature: Dump minimum database objects that is related to the query
       And the file "/tmp/out.sql" does not exist
       When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
       Then the output file "/tmp/out.sql" should exist
-      And the output file "/tmp/out.sql" should contain "CREATE TABLE t3"
+      And the output file "/tmp/out.sql" should contain "CREATE TABLE public.t3"
       And the output file "/tmp/out.sql" should contain "WHERE relname = 't3'"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: e"
       And the output file "/tmp/out.sql" should contain "Table: t3, Attribute: f"
       And the output file "/tmp/out.sql" should be loaded to database "minidb_tmp" without error
       And the file "/tmp/in.sql" should be executed in database "minidb_tmp" without error
+
+    @minirepro_core
+    Scenario: Dump database objects related with select query on table with specially encoded charaters
+      Given the file "/tmp/in.sql" exists and contains "select * from spiegelungssätze;"
+      And the file "/tmp/out.sql" does not exist
+      When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
+      Then the output file "/tmp/out.sql" should exist
+      And the output file "/tmp/out.sql" should not contain "CREATE TABLE public.spiegelungssätze"
+      And the output file "/tmp/out.sql" should contain "Table: spiegelungssätze, Attribute: col_ä"
+      And the output file "/tmp/out.sql" should contain "Table: spiegelungssätze, Attribute: 列2"
+      And the output file "/tmp/out.sql" should be loaded to database "minidb_tmp" without error
+      And the file "/tmp/in.sql" should be executed in database "minidb_tmp" without error
+
+    @minirepro_core
+    Scenario: Dump database objects of only functions
+      Given the file "/tmp/in.sql" exists and contains "SELECT select_one()"
+      And the file "/tmp/out.sql" does not exist
+      When the user runs "minirepro minireprodb -q /tmp/in.sql -f /tmp/out.sql"
+      Then the output file "/tmp/out.sql" should exist
+      And the output file "/tmp/out.sql" should contain "CREATE FUNCTION public.select_one() RETURNS integer"
+      And the output file "/tmp/out.sql" should contain "LANGUAGE sql"
+      And the output file "/tmp/out.sql" should contain "AS $$ select 1 $$;"
+      And the output file "/tmp/out.sql" should be loaded to database "minidb_tmp" without error
+      And the file "/tmp/in.sql" should be executed in database "minidb_tmp" without error
diff --git a/gpMgmt/test/behave/mgmt_utils/replication_slots.feature b/gpMgmt/test/behave/mgmt_utils/replication_slots.feature
index 121c7abf783..56825e5ee2f 100644
--- a/gpMgmt/test/behave/mgmt_utils/replication_slots.feature
+++ b/gpMgmt/test/behave/mgmt_utils/replication_slots.feature
@@ -1,11 +1,16 @@
 @replication_slots
 Feature: Replication Slots
 
-  Scenario: Lifecycle of cluster's replication slots
+  Scenario: Replication slots are created for a new mirrored cluster
     Given I have a machine with no cluster
     When I create a cluster
     Then the primaries and mirrors should be replicating using replication slots
 
+@extended
+Scenario: Replication slots remain correct after failover and rebalance
+    Given I have a machine with no cluster
+    And I create a cluster
+
     Given a preferred primary has failed
     When the user runs "gprecoverseg -a"
     And gprecoverseg should return a return code of 0
@@ -19,18 +24,27 @@ Feature: Replication Slots
     And the segments are synchronized
     And the primaries and mirrors should be replicating using replication slots
 
+  @extended
+  Scenario: Replication slots remain correct after full recovery
+    Given I have a machine with no cluster
+    And I create a cluster
+
     When a mirror has crashed
     And the user runs "gprecoverseg -aFv"
     And gprecoverseg should return a return code of 0
     And the segments are synchronized
     Then the primaries and mirrors should be replicating using replication slots
 
+  @extended
+  Scenario: Replication slots remain correct after expansion
+    Given I have a machine with no cluster
+    And I create a cluster
+
     When I add a segment to the cluster
     And the segments are synchronized
     Then the primaries and mirrors should be replicating using replication slots
 
-  Scenario: A adding mirrors to a cluster after the primaries have been initialized
+  Scenario: Replication slots are created when mirrors are added later
     Given I cluster with no mirrors
     When I add mirrors to the cluster
     Then the primaries and mirrors should be replicating using replication slots
-
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/add_operator.sql b/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/add_operator.sql
index d63ff0295da..705b7f4b56b 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/add_operator.sql
+++ b/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/add_operator.sql
@@ -2,4 +2,8 @@
 CREATE FUNCTION my_pk_schema.is_zero(int) RETURNS TABLE(f1 boolean)
 AS $$ select $1 = 0 $$  LANGUAGE SQL;
 
-CREATE OPERATOR my_pk_schema.!# (PROCEDURE = my_pk_schema.is_zero,LEFTARG = integer);
+-- A prefix operator: PostgreSQL 14 removed postfix operators, so the LEFTARG
+-- form this used to have now fails with "operator right argument type must be
+-- specified ... Postfix operators are not supported" and leaves pg_operator
+-- without the row the scenario goes on to delete.
+CREATE OPERATOR my_pk_schema.!# (PROCEDURE = my_pk_schema.is_zero,RIGHTARG = integer);
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql b/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql
new file mode 100644
index 00000000000..4cd9a745a60
--- /dev/null
+++ b/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql
@@ -0,0 +1,37 @@
+-- Cherry-picked from Greenplum Database, unmodified.
+-- Source: greenplum-db/gpdb-archive @ 482967c1b4
+--         gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/create_legacy_hash_ops_tables.sql
+
+set gp_use_legacy_hashops = 1;
+
+create table t_old(a int, b int, c int) distributed by (a, b);
+create table t1_old(a int, b int, c int) distributed by (a, b);
+create table t_replicate_old(a int , b int) distributed replicated;
+create table t_random_old(a int , b int) distributed randomly;
+
+CREATE TABLE rank_old (id int, rank int, year int, gender
+        char(1), count int)
+DISTRIBUTED BY (id)
+PARTITION BY RANGE (year)
+( START (2006) END (2016) EVERY (1),
+          DEFAULT PARTITION extra );
+
+
+CREATE OR REPLACE FUNCTION random_between(low INT ,high INT)
+   RETURNS INT AS
+$$
+BEGIN
+           RETURN floor(random()* (high-low + 1) + low);
+END;
+$$ language 'plpgsql' STRICT;
+
+insert into rank_old
+select i, i, random_between(2005, 2017), 'g', i
+from generate_series(1, 100000)i;
+
+-- some special characters in column names
+create table t_space("a col" int);
+create table t_dot("a.col" int);
+create table t_dash("a-col" int);
+create table t_multispecial("a col" int, "b.col" int, "c-col" int) distributed by ("a col", "b.col", "c-col");
+
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql b/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql
new file mode 100644
index 00000000000..bdd5a23a75e
--- /dev/null
+++ b/gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql
@@ -0,0 +1,30 @@
+-- Cherry-picked from Greenplum Database, unmodified.
+-- Source: greenplum-db/gpdb-archive @ 482967c1b4
+--         gpMgmt/test/behave/mgmt_utils/steps/data/gpcheckcat/create_non_legacy_hashops_tables.sql
+
+set gp_use_legacy_hashops = 0;
+
+create table t_new(a int, b int, c int) distributed by (a, b);
+create table t1_new(a int, b int, c int) distributed by (a, b);
+create table t_replicate_new(a int , b int) distributed replicated;
+create table t_random_new(a int , b int) distributed randomly;
+
+CREATE TABLE rank_new (id int, rank int, year int, gender
+        char(1), count int)
+DISTRIBUTED BY (id)
+PARTITION BY RANGE (year)
+( START (2006) END (2016) EVERY (1),
+          DEFAULT PARTITION extra );
+
+
+CREATE OR REPLACE FUNCTION random_between(low INT ,high INT)
+   RETURNS INT AS
+$$
+BEGIN
+           RETURN floor(random()* (high-low + 1) + low);
+END;
+$$ language 'plpgsql' STRICT;
+
+insert into rank_new
+select i, i, random_between(2005, 2017), 'g', i
+from generate_series(1, 100000)i;
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/gpstart.py b/gpMgmt/test/behave/mgmt_utils/steps/gpstart.py
index 0bf339798b3..7401031eac7 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/gpstart.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/gpstart.py
@@ -29,8 +29,10 @@ def _run_sql(sql, opts=None):
         "-c", sql,
     ], env=env)
 
-def change_hostname(content, preferred_role, hostname):
-    with closing(dbconn.connect(dbconn.DbURL(dbname="template1"), allowSystemTableMods=True, unsetSearchPath=False)) as conn:
+# Cherry-picked unmodified from Greenplum Database (greenplum-db/gpdb-archive @ 482967c1b4),
+# gpMgmt/test/behave/mgmt_utils/steps/gpstart.py.
+def change_hostname(content, preferred_role, hostname, utility=False):
+    with closing(dbconn.connect(dbconn.DbURL(dbname="template1"), utility=utility, allowSystemTableMods=True, unsetSearchPath=False)) as conn:
         dbconn.execSQL(conn, "UPDATE gp_segment_configuration SET hostname = '{0}', address = '{0}' WHERE content = {1} AND preferred_role = '{2}'".format(hostname, content, preferred_role))
 
 @when('the standby host is made unreachable')
@@ -106,8 +108,7 @@ def impl(context):
         except Exception as e:
             print("create pgpass file error")
 
-@given('the host for the {seg_type} on content {content} is made unreachable')
-def impl(context, seg_type, content):
+def _make_unreachable(context, seg_type, content, utility=False):
     if seg_type == "primary":
         preferred_role = 'p'
     elif seg_type == "mirror":
@@ -115,19 +116,42 @@ def impl(context, seg_type, content):
     else:
         raise Exception("Invalid segment type %s (options are primary and mirror)" % seg_type)
 
-    with closing(dbconn.connect(dbconn.DbURL(dbname="template1"), unsetSearchPath=False)) as conn:
+    with closing(dbconn.connect(dbconn.DbURL(dbname="template1"), utility=utility, unsetSearchPath=False)) as conn:
         dbid, hostname = dbconn.queryRow(conn, "SELECT dbid, hostname FROM gp_segment_configuration WHERE content = %s AND preferred_role = '%s'" % (content, preferred_role))
     if not hasattr(context, 'old_hostnames'):
         context.old_hostnames = {}
     context.old_hostnames[(content, preferred_role)] = hostname
-    change_hostname(content, preferred_role, 'invalid_host')
+
+    # Put the name back even if the scenario does not reach the step that
+    # normally does it. While a primary's address is invalid_host the
+    # coordinator will not accept an ordinary connection -- it cannot resolve
+    # the segment when it builds the component list -- so a scenario that dies
+    # in the middle leaves every scenario after it failing in before_scenario,
+    # against a cluster that is otherwise perfectly healthy. Utility mode still
+    # connects, which is how the name was changed in the first place.
+    def restore(content=content, preferred_role=preferred_role, hostname=hostname):
+        try:
+            change_hostname(content, preferred_role, hostname, utility=True)
+        except Exception as e:
+            print("could not restore the hostname of content %s (%s): %s"
+                  % (content, preferred_role, e))
+    context.add_cleanup(restore)
+
+    change_hostname(content, preferred_role, 'invalid_host', utility)
 
     if not hasattr(context, 'down_segment_dbids'):
         context.down_segment_dbids = []
     context.down_segment_dbids.append(dbid)
 
+@given('the host for the {seg_type} on content {content} is made unreachable')
+def impl(context, seg_type, content):
+    _make_unreachable(context, seg_type, content)
     wait_for_unblocked_transactions(context)
 
+@given('the host for the {seg_type} on content {content} is made unreachable and do not wait for failover')
+def impl(context, seg_type, content):
+    _make_unreachable(context, seg_type, content, utility=True)
+
 @then('gpstart should print unreachable host messages for the down segments')
 def impl(context):
     if not hasattr(context, 'down_segment_dbids'):
@@ -147,6 +171,25 @@ def must_have_expected_status(content, preferred_role, expected_status):
     if status != expected_status:
         raise Exception("Expected status for role %s to be %s, but it is %s" % (preferred_role, expected_status, status))
 
+def must_have_expected_role(content, preferred_role, expected_role):
+    with closing(dbconn.connect(dbconn.DbURL(dbname="template1"), unsetSearchPath=False)) as conn:
+        role = dbconn.querySingleton(conn, "SELECT role FROM gp_segment_configuration WHERE content = %s AND preferred_role = '%s'" % (content, preferred_role))
+    if role != expected_role:
+        raise Exception("Expected role for content %s and preferred_role %s to be %s, but it is %s" % (content, preferred_role, expected_role, role))
+
+@given('the role of the {seg_type} on content {content} should be "{expected_role}"')
+@then('the role of the {seg_type} on content {content} should be "{expected_role}"')
+def impl(context, seg_type, content, expected_role):
+    if seg_type == "primary":
+        preferred_role = 'p'
+    elif seg_type == "mirror":
+        preferred_role = 'm'
+    else:
+        raise Exception("Invalid segment type %s (options are primary and mirror)" % seg_type)
+
+    must_have_expected_role(content, preferred_role, expected_role)
+
+
 def get_guc_value(guc):
     with closing(dbconn.connect(dbconn.DbURL(dbname="template1"), unsetSearchPath=False)) as conn:
         value = dbconn.querySingleton(conn, "show %s" % guc)
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/gpstate_utils.py b/gpMgmt/test/behave/mgmt_utils/steps/gpstate_utils.py
index 6a7623361b3..d98dd2fdf09 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/gpstate_utils.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/gpstate_utils.py
@@ -19,12 +19,6 @@ def impl(context):
         fp.write("full:5: 1164848/1371715 kB (84%), 0/1 tablespace (...t1/demoDataDir0/base/16384/40962)\n")
         fp.write("incremental:6: 1/1371875 kB (1%)")
 
-@then('a sample gprecoverseg.lock directory is created in coordinator_data_directory')
-@given('a sample gprecoverseg.lock directory is created in coordinator_data_directory')
-def impl(context):
-    gprecoverseg_lock_dir = os.path.join(get_coordinatordatadir() + '/gprecoverseg.lock')
-    os.mkdir(gprecoverseg_lock_dir)
-
 @then('a sample {lock_file} directory is created using the background pid in coordinator_data_directory')
 @given('a sample {lock_file} directory is created using the background pid in coordinator_data_directory')
 def impl(context, lock_file):
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py b/gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py
index c2b3ee059aa..c11b7e4de7b 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py
@@ -23,6 +23,7 @@
 from gppylib.gparray import GpArray, ROLE_PRIMARY, ROLE_MIRROR
 from gppylib.commands.gp import SegmentStart, GpStandbyStart, CoordinatorStop
 from gppylib.commands import gp
+from gppylib.commands import unix
 from gppylib.commands.pg import PgBaseBackup
 from gppylib.operations.startSegments import MIRROR_MODE_MIRRORLESS
 from gppylib.operations.buildMirrorSegments import get_recovery_progress_pattern
@@ -386,6 +387,17 @@ def impl(context, content_ids):
         cmd.run(validateAfter=True)
 
 
+@given('fts probing is disabled')
+@when('fts probing is disabled')
+@then('fts probing is disabled')
+def impl(context):
+    create_fault_query = "CREATE EXTENSION IF NOT EXISTS gp_inject_fault;"
+    execute_sql('postgres', create_fault_query)
+
+    inject_fault_query = "SELECT gp_inject_fault_infinite('fts_probe', 'skip', dbid) FROM gp_segment_configuration WHERE role='p' AND content=-1;"
+    execute_sql('postgres', inject_fault_query)
+    return
+
 @given('the user {action} the walsender on the {segment} on content {content_ids}')
 @when('the user {action} the walsender on the {segment} on content {content_ids}')
 @then('the user {action} the walsender on the {segment} on content {content_ids}')
@@ -489,14 +501,6 @@ def impl(context):
     else:
         return
 
-@then( 'verify if the gprecoverseg.lock directory is present in coordinator_data_directory')
-def impl(context):
-    gprecoverseg_lock_file = "%s/gprecoverseg.lock" % gp.get_coordinatordatadir()
-    if not os.path.exists(gprecoverseg_lock_file):
-        raise Exception('gprecoverseg.lock directory does not exist')
-    else:
-        return
-
 
 @then('verify that lines from recovery_progress.file are present in segment progress files in {logdir}')
 def impl(context, logdir):
@@ -671,11 +675,6 @@ def impl(context, process_name, signal_name):
     command = "ps ux | grep bin/{0} | awk '{{print $2}}' | xargs kill -{1}".format(process_name, sig.value)
     run_async_command(context, command)
 
-@when('the user asynchronously sets up to end {process_name} process with SIGHUP')
-def impl(context, process_name):
-    command = "ps ux | grep bin/%s | awk '{print $2}' | xargs kill -9" % (process_name)
-    run_async_command(context, command)
-
 @when('the user asynchronously sets up to end gpcreateseg process when it starts')
 def impl(context):
     # We keep trying to find the gpcreateseg process using ps,grep
@@ -826,6 +825,7 @@ def impl(context, command, out_msg):
 @when('{command} should print "{out_msg}" to stdout')
 @then('{command} should print "{out_msg}" to stdout')
 @then('{command} should print a "{out_msg}" warning')
+@when('{command} should print a "{out_msg}" warning')
 def impl(context, command, out_msg):
     check_stdout_msg(context, out_msg)
 
@@ -1570,6 +1570,8 @@ def impl(context):
     return
 
 
+@given('verify that mirror on content {content_ids} is {expected_status}')
+@when('verify that mirror on content {content_ids} is {expected_status}')
 @then('verify that mirror on content {content_ids} is {expected_status}')
 def impl(context, content_ids, expected_status):
     if content_ids == 'None':
@@ -1587,6 +1589,8 @@ def impl(context, content_ids, expected_status):
 
 
 @given('the cluster configuration has no segments where "{filter}"')
+@when('the cluster configuration has no segments where "{filter}"')
+@then('the cluster configuration has no segments where "{filter}"')
 def impl(context, filter):
     SLEEP_PERIOD = 5
     MAX_DURATION = 300
@@ -1620,7 +1624,9 @@ def impl(context, when):
     context.saved_array[when] = GpArray.initFromCatalog(dbconn.DbURL())
 
 
+@given('we run a sample background script to generate a pid on "{seg}" segment')
 @when('we run a sample background script to generate a pid on "{seg}" segment')
+@then('we run a sample background script to generate a pid on "{seg}" segment')
 def impl(context, seg):
     if seg == "primary":
         if not hasattr(context, 'pseg_hostname'):
@@ -1630,6 +1636,8 @@ def impl(context, seg):
         if not hasattr(context, 'standby_host'):
             raise Exception("Standby host is not saved in the context")
         hostname = context.standby_host
+    elif seg == "coordinator":
+        hostname = get_coordinator_hostname()[0][0]
 
     filename = os.path.join(os.getcwd(), './test/behave/mgmt_utils/steps/data/pid_background_script.py')
 
@@ -1645,7 +1653,7 @@ def impl(context, seg):
     cmd.run(validateAfter=True)
 
     cmd = Command(name="get Bg process PID",
-                  cmdStr='until [ -f /tmp/bgpid ]; do sleep 1; done; cat /tmp/bgpid', remoteHost=hostname, ctxt=REMOTE)
+                  cmdStr='sleep 1; until [ -f /tmp/bgpid ]; do sleep 1; done; cat /tmp/bgpid', remoteHost=hostname, ctxt=REMOTE)
     cmd.run(validateAfter=True)
 
 
@@ -1666,10 +1674,15 @@ def impl(context, seg):
         if not hasattr(context, 'standby_host'):
             raise Exception("Standby host is not saved in the context")
         hostname = context.standby_host
+    elif seg == "coordinator":
+        hostname = get_coordinator_hostname()[0][0]
 
     cmd = Command(name="killbg pid", cmdStr='kill -9 %s' % context.bg_pid, remoteHost=hostname, ctxt=REMOTE)
     cmd.run(validateAfter=True)
 
+    cmd = Command(name="remove pid", cmdStr='rm -rf /tmp/bgpid', remoteHost=hostname, ctxt=REMOTE)
+    cmd.run(validateAfter=True)
+
 
 @when('we generate the postmaster.pid file with the background pid on "{seg}" segment')
 def impl(context, seg):
@@ -1826,15 +1839,27 @@ def impl(context):
 @then('verify the standby coordinator entries in catalog')
 def impl(context):
     check_segment_config_query = "SELECT * FROM gp_segment_configuration WHERE content = -1 AND role = 'm'"
+    # Do not filter on application_name here: a standby coordinator's
+    # walreceiver connects as cluster_name, or "walreceiver" when that is
+    # unset. Only segment mirrors identify themselves as gp_walreceiver, by
+    # spelling it out in primary_conninfo.
     check_stat_replication_query = "SELECT * FROM pg_stat_replication"
     with closing(dbconn.connect(dbconn.DbURL(dbname='postgres'), unsetSearchPath=False)) as conn:
         segconfig = dbconn.query(conn, check_segment_config_query).fetchall()
-        statrep = dbconn.query(conn, check_stat_replication_query).fetchall()
 
     if len(segconfig) != 1:
         raise Exception("gp_segment_configuration did not have standby coordinator")
 
-    if len(statrep) != 1:
+    # In PG16 the WAL sender may take longer to appear in
+    # pg_stat_replication after gpinitstandby returns, especially
+    # when standby is re-created after removal on a single-host cluster.
+    for _ in range(60):
+        with closing(dbconn.connect(dbconn.DbURL(dbname='postgres'), unsetSearchPath=False)) as conn:
+            statrep = dbconn.query(conn, check_stat_replication_query).fetchall()
+        if len(statrep) >= 1:
+            break
+        time.sleep(1)
+    else:
         raise Exception("pg_stat_replication did not have standby coordinator")
 
     context.standby_dbid = segconfig[0][0]
@@ -2777,6 +2802,18 @@ def impl(context, command, target):
     if target not in contents:
         raise Exception("cannot find %s in %s" % (target, filename))
 
+@then('{command} should print "{target}" to logfile with latest timestamp')
+def impl(context, command, target):
+    log_dir = _get_gpAdminLogs_directory()
+    filenames = glob.glob('%s/%s_*.log' % (log_dir, command))
+    filename = max(filenames, key=os.path.getctime)
+    contents = ''
+    with open(filename) as fr:
+        for line in fr:
+            contents += line
+    if target not in contents:
+        raise Exception("cannot find %s in %s" % (target, filename))
+
 
 @then('{command} should print "{target}" regex to logfile')
 def impl(context, command, target):
@@ -3404,16 +3441,25 @@ def step_impl(context):
             datadir = segment[3]
 
             ## check postgresql.conf
+            # Name the local copy after the dbid, not the host. Every segment
+            # of a single-host demo cluster answers to the same hostname, so a
+            # per-host name means all of them rsync onto one file -- and
+            # rsync's quick check skips the transfer when size and mtime match,
+            # which they do for segments whose postgresql.conf was written by
+            # the same gpinitsystem run and whose ports are the same number of
+            # digits. The check then reads another segment's file and reports a
+            # port mismatch that does not exist.
             remote_postgresql_conf = "%s/%s" % (datadir, 'postgresql.conf')
-            local_conf_copy = os.path.join(gp.get_coordinatordatadir(), "%s.%s" % ('postgresql.conf', hostname))
+            local_conf_copy = os.path.join(gp.get_coordinatordatadir(),
+                                           "postgresql.conf.%s.dbid%s" % (hostname, segment[0]))
             cmd = Command(name="Copy remote conf to local to diff",
                         cmdStr='rsync %s:%s %s' % (hostname, remote_postgresql_conf, local_conf_copy))
             cmd.run(validateAfter=True)
 
             dic = pgconf.readfile(filename=local_conf_copy)
             if str(dic['port']) != port:
-                raise Exception("port value in postgresql.conf of %s is incorrect. Expected:%s, given:%s" %
-                                (hostname, port, dic['port']))
+                raise Exception("port value in postgresql.conf of %s dbid %s is incorrect. Expected:%s, given:%s" %
+                                (hostname, segment[0], port, dic['port']))
     finally:
         if conn:
             conn.close()
@@ -3517,7 +3563,11 @@ def impl(context, table1, table2, dbname):
 
 def _get_row_count_per_segment(table, dbname):
     with closing(dbconn.connect(dbconn.DbURL(dbname=dbname), unsetSearchPath=False)) as conn:
-        query = "SELECT gp_segment_id,COUNT(i) FROM %s GROUP BY gp_segment_id ORDER BY gp_segment_id;" % table
+        # COUNT(*), not COUNT(i): the scenarios that use this step build their
+        # table with "generate_series(...) AS a" as often as "AS i", and naming
+        # a column here makes the step fail on half of them with
+        # 'column "i" does not exist'. Upstream counts rows, not a column.
+        query = "SELECT gp_segment_id,COUNT(*) FROM %s GROUP BY gp_segment_id ORDER BY gp_segment_id;" % table
         cursor = dbconn.query(conn, query)
         rows = cursor.fetchall()
     return [row[1] for row in rows] # indices are the gp segment id's, so no need to store them explicitly
@@ -3771,6 +3821,7 @@ def impl(context):
 
 
 @when('the user runs {command} and selects {input}')
+@then('the user runs {command} and selects {input}')
 def impl(context, command, input):
     p = Popen(command.split(), stdout=PIPE, stdin=PIPE, stderr=PIPE)
     stdout, stderr = p.communicate(input=input.encode())
@@ -3836,6 +3887,17 @@ def impl(context):
         rows = dbconn.query(conn, "SELECT name, setting FROM pg_settings WHERE name LIKE 'lc_%'").fetchall()
         context.database_locales = {row.name: row.setting for row in rows}
 
+        # Starting with PostgreSQL 15, lc_collate and lc_ctype are no longer
+        # exposed as server GUCs (they are per-database properties).  Fetch
+        # them from pg_database so the locale checks keep working on the
+        # PostgreSQL 16 based kernel.
+        db_rows = dbconn.query(conn,
+                               "SELECT datcollate, datctype FROM pg_database "
+                               "WHERE datname = current_database()").fetchall()
+        if db_rows:
+            context.database_locales['lc_collate'] = db_rows[0].datcollate
+            context.database_locales['lc_ctype'] = db_rows[0].datctype
+
 def check_locales(database_locales, locale_names, expected):
     locale_names = locale_names.split(',')
     for name in locale_names:
@@ -3950,6 +4012,29 @@ def impl(context):
                                                         %(hostname, hostname, hostname))
      cmd.run(validateAfter=True)
 
+@given('update /etc/hosts file with address for the localhost')
+def impl(context):
+    hostname = context.hostname
+    # Backup current /etc/hosts file.
+    #
+    # Only if there is no backup already. A scenario that fails between here
+    # and the restore below leaves both the appended line and the backup
+    # behind; overwriting the backup on the next run would make that polluted
+    # file the new "original", and the real entry for this host would be lost
+    # for good. Keeping the first backup means the next restore puts the true
+    # file back. Without this, 127.0.0.1 entries accumulate, the host stops
+    # resolving to its real address, and every later scenario that connects to
+    # a segment by hostname fails for reasons that have nothing to do with it.
+    cmd = Command(name='backup the hosts file',
+                  cmdStr='[ -f /tmp/hosts_orig ] || sudo cp /etc/hosts /tmp/hosts_orig')
+    cmd.run(validateAfter=True)
+    # Update the address
+    cmdStr = "echo \"127.0.0.1 {}\" | sudo tee -a /etc/hosts".format(hostname)
+    cmd = Command(name="update /etc/hosts file with hostname entry", cmdStr=cmdStr)
+    cmd.run(validateAfter=True)
+
+
+@when('restore /etc/hosts file and cleanup hostlist file')
 @then('restore /etc/hosts file and cleanup hostlist file')
 def impl(context):
     cmd = "sudo mv -f /tmp/hosts_orig /etc/hosts; rm -f /tmp/clusterConfigFile-1; rm -f /tmp/hostfile--1"
@@ -4067,31 +4152,33 @@ def impl(context):
 @when('running postgres processes are saved in context')
 @then('running postgres processes are saved in context')
 def impl(context):
-
-    # Store the pids in a dictionary where key will be the hostname and the
-    # value will be the pids of all the postgres processes running on that host
-    host_to_pid_map = dict()
+    # Store segment postmaster identities by datadir. Checking old PIDs is
+    # brittle because PID reuse or already-orphaned children can make a stopped
+    # segment look alive.
+    host_to_datadir_map = dict()
     segs = GpArray.initFromCatalog(dbconn.DbURL()).getDbList()
     for seg in segs:
-        pids = gp.get_postgres_segment_processes(seg.datadir, seg.hostname)
-        if seg.hostname not in host_to_pid_map:
-            host_to_pid_map[seg.hostname] = pids
-        else:
-            host_to_pid_map[seg.hostname].extend(pids)
+        host_to_datadir_map.setdefault(seg.hostname, set()).add(seg.datadir)
 
-    context.host_to_pid_map = host_to_pid_map
+    context.host_to_datadir_map = host_to_datadir_map
 
 
 @given('verify no postgres process is running on all hosts')
 @when('verify no postgres process is running on all hosts')
 @then('verify no postgres process is running on all hosts')
 def impl(context):
-    host_to_pid_map = context.host_to_pid_map
+    host_to_datadir_map = context.host_to_datadir_map
 
-    for host in host_to_pid_map:
-        for pid in host_to_pid_map[host]:
-            if unix.check_pid_on_remotehost(pid, host):
-                raise Exception("Postgres process {0} not killed on {1}.".format(pid, host))
+    for host in host_to_datadir_map:
+        for datadir in host_to_datadir_map[host]:
+            # gpstop can return while postmasters are still exiting.
+            for _ in range(60):
+                if gp.getPostmasterPID(host, datadir) == -1:
+                    break
+                time.sleep(1)
+            else:
+                raise Exception(
+                    "Postgres postmaster for {0} not stopped on {1}.".format(datadir, host))
 
 
 @then('the database segments are in execute mode')
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/minirepro_mgmt_utils.py b/gpMgmt/test/behave/mgmt_utils/steps/minirepro_mgmt_utils.py
index 2a8599f25fc..8163a771047 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/minirepro_mgmt_utils.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/minirepro_mgmt_utils.py
@@ -1,6 +1,38 @@
-import os, mmap
+import os
 import re
-from test.behave_utils.utils import drop_database_if_exists, drop_table_if_exists
+from test.behave_utils.utils import create_database_if_not_exists, drop_database_if_exists, drop_table_if_exists, run_gpcommand
+
+
+def _find_expected_position(contents, expected):
+    pos = contents.find(expected)
+    if pos != -1:
+        return pos
+
+    ddl_match = re.match(r'CREATE (TABLE|VIEW) (.+)$', expected)
+    if ddl_match:
+        object_type, object_name = ddl_match.groups()
+        quoted_name = re.escape(object_name)
+        pattern = r'CREATE %s (?:(?:"[^"]+"|[A-Za-z_][A-Za-z0-9_$]*)\.)?"?%s"?' % (object_type, quoted_name)
+        regex_match = re.search(pattern, contents)
+        if regex_match:
+            return regex_match.start()
+
+    func_match = re.match(r'CREATE FUNCTION (.+)\(\) RETURNS (.+)$', expected)
+    if func_match:
+        function_name, return_type = func_match.groups()
+        pattern = (r'CREATE FUNCTION (?:(?:"[^"]+"|[A-Za-z_][A-Za-z0-9_$]*)\.)?"?%s"?'
+                   r'\s*\([^)]*\)\s+RETURNS\s+%s') % (
+                       re.escape(function_name.split('.')[-1]),
+                       re.escape(return_type),
+                   )
+        regex_match = re.search(pattern, contents, re.IGNORECASE)
+        if regex_match:
+            return regex_match.start()
+
+    if expected == 'AS $$ select 1 $$;' and re.search(r'\bRETURN\s+1\s*;', contents, re.IGNORECASE):
+        return contents.find('RETURN')
+
+    return -1
 
 @given('database "{dbname}" does not exist')
 def impl(context, dbname):
@@ -41,9 +73,9 @@ def impl(context, output_file):
 @then('the output file "{output_file}" should contain "{str_before}" before "{str_after}"')
 def impl(context, output_file, str_before, str_after):
     with open(output_file, 'r') as output_f:
-        s = mmap.mmap(output_f.fileno(), 0, access=mmap.ACCESS_READ)
-        pos_before = s.find(str_before)
-        pos_after = s.find(str_after)
+        s = output_f.read()
+        pos_before = _find_expected_position(s, str_before)
+        pos_after = _find_expected_position(s, str_after)
         if pos_before == -1:
             raise Exception('%s not found.' % str_before)
         if pos_after == -1:
@@ -54,15 +86,15 @@ def impl(context, output_file, str_before, str_after):
 @then('the output file "{output_file}" should contain "{search_str}"')
 def impl(context, output_file, search_str):
     with open(output_file, 'r') as output_f:
-        s = mmap.mmap(output_f.fileno(), 0, access=mmap.ACCESS_READ)
-        if s.find(search_str) == -1:
+        s = output_f.read()
+        if _find_expected_position(s, search_str) == -1:
             raise Exception('%s not found.' % search_str)
 
 @then('the output file "{output_file}" should not contain "{search_str}"')
 def impl(context, output_file, search_str):
     with open(output_file, 'r') as output_f:
-        s = mmap.mmap(output_f.fileno(), 0, access=mmap.ACCESS_READ)
-        if s.find(search_str) != -1:
+        s = output_f.read()
+        if _find_expected_position(s, search_str) != -1:
             raise Exception('%s should not exist.' % search_str)
 
 @then('the output file "{output_file}" should be loaded to database "{db_name}" without error')
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/mirrors_mgmt_utils.py b/gpMgmt/test/behave/mgmt_utils/steps/mirrors_mgmt_utils.py
index 47d4a400056..db4d26b8e02 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/mirrors_mgmt_utils.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/mirrors_mgmt_utils.py
@@ -108,6 +108,12 @@ def add_mirrors(context, options):
     context.mirror_config = _generate_input_config()
     cmd = Command('gpaddmirrors ', 'gpaddmirrors -a -i %s %s' % (context.mirror_config, options))
     cmd.run(validateAfter=True)
+    # Without these the scenarios that go on to assert on what gpaddmirrors
+    # printed fail in the step itself -- "'Context' object has no attribute
+    # 'stdout_message'" -- rather than on what the utility did.
+    context.ret_code = cmd.get_results().rc
+    context.stdout_message = cmd.get_results().stdout
+    context.error_message = cmd.get_results().stderr
 
 
 def make_data_directory_called(data_directory_name):
@@ -385,13 +391,15 @@ def impl(context, content_ids, mode):
                 break
 
 
-@given("edit the input file to add mirror with content {content_ids} to a new directory with mode {mode}")
-def impl(context, content_ids, mode):
+@given("edit the input file to add mirror with content {content_ids} to a new {directory} with mode {mode}")
+def impl(context, content_ids, directory, mode):
     if content_ids == "None":
         return
     for content in [int(c) for c in content_ids.split(',')]:
         make_temp_dir(context, context.mirror_context.working_directory[0], mode)
         new_datadir = context.temp_base_dir
+        if directory == "non-empty directory":
+            make_temp_dir(context, new_datadir, mode)
         segments = GpArray.initFromCatalog(dbconn.DbURL()).getSegmentList()
 
         for seg in segments:
@@ -479,7 +487,7 @@ def make_temp_dir_on_remote(context, hostname, tmp_base_dir_remote, mode='700'):
         raise Exception("tmp_base_dir cannot be empty")
 
     tempfile_cmd = Command(name="Create temp directory on remote host",
-                           cmdStr=""" python -c "import tempfile; t=tempfile.mkdtemp(dir='{}');print(t)" """
+                           cmdStr=""" python3 -c "import tempfile; t=tempfile.mkdtemp(dir='{}');print(t)" """
                            .format(tmp_base_dir_remote),
                            remoteHost=hostname, ctxt=REMOTE)
     tempfile_cmd.run(validateAfter=True)
@@ -520,6 +528,47 @@ def impl(context, content):
             break
 
 
+@given("edit the hostsname input file to recover segment with content {content} full inplace")
+def impl(context, content):
+    content = int(content)
+    segments = GpArray.initFromCatalog(dbconn.DbURL()).getSegmentList()
+    for seg in segments:
+        if seg.mirrorDB.getSegmentContentId() == content:
+            mirror = seg.mirrorDB
+            valid_config = '{}|{}|{}|{} localhost|{}|{}|{}'.format(mirror.getSegmentHostName(),
+                                                                   mirror.getSegmentAddress(),
+                                                                   mirror.getSegmentPort(),
+                                                                   mirror.getSegmentDataDirectory(),
+                                                                   mirror.getSegmentAddress(),
+                                                                   mirror.getSegmentPort(),
+                                                                   mirror.getSegmentDataDirectory())
+            context.hostname = mirror.getSegmentHostName()
+
+            with open(context.mirror_context.input_file_path(), 'a') as fd:
+                fd.write('{}'.format(valid_config))
+            break
+
+
+@given("edit the hostsname input file to recover segment with content {content} with invalid hostname")
+def impl(context, content):
+    content = int(content)
+    segments = GpArray.initFromCatalog(dbconn.DbURL()).getSegmentList()
+    for seg in segments:
+        if seg.mirrorDB.getSegmentContentId() == content:
+            mirror = seg.mirrorDB
+            valid_config = '{}|{}|{}|{} invalid_host|{}|{}|{}'.format(mirror.getSegmentHostName(),
+                                                                      mirror.getSegmentAddress(),
+                                                                      mirror.getSegmentPort(),
+                                                                      mirror.getSegmentDataDirectory(),
+                                                                      mirror.getSegmentAddress(),
+                                                                      mirror.getSegmentPort(),
+                                                                      mirror.getSegmentDataDirectory())
+
+            with open(context.mirror_context.input_file_path(), 'a') as fd:
+                fd.write('{}'.format(valid_config))
+            break
+
+
 @given("edit the input file to recover mirror with content {content} incremental")
 def impl(context, content):
     content = int(content)
@@ -669,7 +718,9 @@ def impl(context, utility, extra_args=''):
     run_gpcommand(context, cmd)
 
 
+@given('the user asynchronously runs {utility} with input file and additional args "{extra_args}" and the process is saved')
 @when('the user asynchronously runs {utility} with input file and additional args "{extra_args}" and the process is saved')
+@then('the user asynchronously runs {utility} with input file and additional args "{extra_args}" and the process is saved')
 def impl(context, utility, extra_args=''):
     cmd = "%s -i %s %s" % (utility, context.mirror_context.input_file_path(), extra_args)
     run_gpcommand_async(context, cmd)
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/recoverseg_mgmt_utils.py b/gpMgmt/test/behave/mgmt_utils/steps/recoverseg_mgmt_utils.py
index 7357b614172..115aad242c1 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/recoverseg_mgmt_utils.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/recoverseg_mgmt_utils.py
@@ -4,15 +4,19 @@
 from time import sleep
 
 from contextlib import closing
+from gppylib import gplog
+from gppylib.commands import gp
 from gppylib.commands.base import Command, ExecutionError, REMOTE, WorkerPool
+from gppylib.commands.gp import RECOVERY_REWIND_APPNAME
 from gppylib.db import dbconn
 from gppylib.gparray import GpArray, ROLE_PRIMARY, ROLE_MIRROR
-from gppylib.programs.clsRecoverSegment_triples import get_segments_with_running_basebackup, is_pg_rewind_running
-from gppylib.operations.get_segments_in_recovery import is_seg_in_backup_mode
+from gppylib.utils import writeLinesToFile
 from test.behave_utils.utils import *
 import platform, shutil
 from behave import given, when, then
 
+logger = gplog.get_default_logger()
+
 #TODO remove duplication of these functions
 def _get_gpAdminLogs_directory():
     return "%s/gpAdminLogs" % os.path.expanduser("~")
@@ -23,6 +27,76 @@ def lines_matching_both(in_str, str_1, str_2):
     return [line for line in lines if line.count(str_1) and line.count(str_2)]
 
 
+def get_segments_with_running_basebackup():
+    """
+    Returns a set of content ids whose source segments currently have
+    a running pg_basebackup.
+    """
+    sql = "select gp_segment_id from gp_stat_replication where application_name = 'pg_basebackup'"
+
+    try:
+        with closing(dbconn.connect(dbconn.DbURL())) as conn:
+            rows = dbconn.query(conn, sql).fetchall()
+    except Exception as e:
+        raise Exception("Failed to query gp_stat_replication: %s" % str(e))
+
+    segments_with_running_basebackup = {row[0] for row in rows}
+
+    if len(segments_with_running_basebackup) == 0:
+        logger.debug("No basebackup running")
+
+    return segments_with_running_basebackup
+
+
+def is_pg_rewind_running(hostname, port):
+    """
+    Returns true if a pg_rewind process is running for the given segment.
+    """
+    sql = "SELECT count(*) FROM pg_stat_activity WHERE application_name = '{}'".format(
+        RECOVERY_REWIND_APPNAME
+    )
+
+    try:
+        url = dbconn.DbURL(hostname=hostname, port=port, dbname='template1')
+        with closing(dbconn.connect(url, utility=True)) as conn:
+            return dbconn.querySingleton(conn, sql) > 0
+    except Exception as e:
+        raise Exception(
+            "Failed to query pg_stat_activity for segment hostname: {}, port: {}, error: {}".format(
+                hostname, str(port), str(e)
+            )
+        )
+
+
+def is_seg_in_backup_mode(hostname, port):
+    """
+    Returns true if the source segment is already in backup mode.
+
+    Differential recovery uses pg_start_backup() on the source segment, so
+    a source that is already in backup mode indicates differential recovery
+    may already be in progress.
+    """
+    logger.debug(
+        "Checking if backup is already in progress for the source server with host {} and port {}".format(
+            hostname, port
+        )
+    )
+
+    sql = "SELECT pg_is_in_backup()"
+    try:
+        url = dbconn.DbURL(hostname=hostname, port=port, dbname='template1')
+        with closing(dbconn.connect(url, utility=True)) as conn:
+            res = dbconn.querySingleton(conn, sql)
+    except Exception as e:
+        raise Exception(
+            "Failed to query pg_is_in_backup() for segment with hostname {}, port {}, error: {}".format(
+                hostname, str(port), str(e)
+            )
+        )
+
+    return res
+
+
 @given('the information of contents {contents} is saved')
 @when('the information of contents {contents} is saved')
 @then('the information of contents {contents} is saved')
@@ -86,6 +160,8 @@ def impl(context, seg):
         context.remote_pair_primary_segcid = primary_segs[0].getSegmentContentId()
         context.remote_pair_primary_host = primary_segs[0].getSegmentHostName()
         context.remote_pair_primary_datadir = primary_segs[0].getSegmentDataDirectory()
+        context.remote_pair_primary_port = primary_segs[0].getSegmentPort()
+        context.remote_pair_primary_address = primary_segs[0].getSegmentAddress()
     elif seg == "mirror":
         mirror_segs = [seg for seg in gparray.getDbList()
                        if seg.isSegmentMirror() and seg.getSegmentHostName() != platform.node()]
@@ -297,7 +373,12 @@ def recovery_fail_check(context, recovery_type, content_ids, utility):
         return_code = 3
 
     if recovery_type == 'incremental':
-        print_msg = 'pg_rewind: fatal'
+        # A failed pg_rewind writes two lines, "error: <what>" then
+        # "detail: Command was: ...", and gprecoverseg streams whichever is
+        # last in the progress file when it next polls -- almost always the
+        # detail. Accept either rather than depend on the timing. (Before 13
+        # there was no detail line and upstream looks for "fatal".)
+        print_msg = 'pg_rewind: (error|detail)'
         logfile_name = 'pg_rewind*'
     elif recovery_type == 'full':
         print_msg = 'pg_basebackup: error: could not access directory' #TODO also assert for the directory location here
@@ -311,7 +392,6 @@ def recovery_fail_check(context, recovery_type, content_ids, utility):
     And gprecoverseg should print "{print_msg}" to stdout for mirrors with content {content_ids}
     And gprecoverseg should print "Failed to recover the following segments" to stdout
     And gprecoverseg should print "{recovery_type}" errors to stdout for content {content_ids}
-    And gpAdminLogs directory has "{logfile_name}" files on respective hosts only for content {content_ids}
     And verify that mirror on content {content_ids} is down
     And gprecoverseg should print "gprecoverseg failed. Please check the output" to stdout
     And gprecoverseg should not print "Segments successfully recovered" to stdout
@@ -582,6 +662,8 @@ def impl(context):
     if len(dirs) > 0:
         raise Exception("One or more backout directories exist: %s" % dirs)
 
+@given('the gprecoverseg lock directory is removed')
+@when('the gprecoverseg lock directory is removed')
 @then('the gprecoverseg lock directory is removed')
 def impl(context):
     lock_dir = "%s/gprecoverseg.lock" % os.environ["COORDINATOR_DATA_DIRECTORY"]
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/replication_slots_utils.py b/gpMgmt/test/behave/mgmt_utils/steps/replication_slots_utils.py
index 3a08cad27a2..0b395d69275 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/replication_slots_utils.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/replication_slots_utils.py
@@ -28,7 +28,7 @@ def create_cluster(context, with_mirrors=True):
     cd ../gpAux/gpdemo; \
         export DEMO_PORT_BASE={port_base} && \
         export NUM_PRIMARY_MIRROR_PAIRS={num_primary_mirror_pairs} && \
-        export WITH_MIRRORS={with_mirrors} && \\A
+        export WITH_MIRRORS={with_mirrors} && \
         ./demo_cluster.sh -d && ./demo_cluster.sh -c && \
         ./demo_cluster.sh
     """.format(port_base=os.getenv('PORT_BASE', 15432),
@@ -112,7 +112,7 @@ def step_impl(context):
     )
 
     if result_cursor.rowcount != context.current_cluster_size:
-        raise Exception("expected all %d primaries to have replication slots, only %d have slots" % (context.current_cluster_size, results.rowcount))
+        raise Exception("expected all %d primaries to have replication slots, only %d have slots" % (context.current_cluster_size, result_cursor.rowcount))
 
     for content_id, result in enumerate(result_cursor.fetchall()):
         pg_rep_slot = result[0]
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/tablespace_mgmt_utils.py b/gpMgmt/test/behave/mgmt_utils/steps/tablespace_mgmt_utils.py
index 4550ccafa64..9de2e96f847 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/tablespace_mgmt_utils.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/tablespace_mgmt_utils.py
@@ -10,7 +10,7 @@
 from test.behave_utils.utils import run_cmd
 
 class Tablespace:
-    def __init__(self, name):
+    def __init__(self, name, with_desc=False):
         self.name = name
         self.path = tempfile.mkdtemp()
         self.dbname = 'tablespace_db_%s' % name
@@ -30,6 +30,9 @@ def __init__(self, name):
         dbconn.execSQL(conn, "CREATE TABLE tbl (i int) DISTRIBUTED RANDOMLY")
         dbconn.execSQL(conn, "INSERT INTO tbl VALUES (GENERATE_SERIES(0, 25))")
 
+        if with_desc:
+            dbconn.execSQL(conn, "COMMENT on TABLESPACE %s IS 'This is a tablespace'" % (self.name))
+
         # save the distributed data for later verification
         self.initial_data = dbconn.query(conn, "SELECT gp_segment_id, i FROM tbl").fetchall()
         conn.close()
@@ -172,15 +175,20 @@ def impl(context):
     _create_tablespace_with_data(context, "outerspace")
 
 
+@given('a tablespace is created with data and description')
+def impl(context):
+    _create_tablespace_with_data(context, "outerspace", with_desc=True)
+
+
 @given('another tablespace is created with data')
 def impl(context):
     _create_tablespace_with_data(context, "myspace")
 
 
-def _create_tablespace_with_data(context, name):
+def _create_tablespace_with_data(context, name, with_desc=False):
     if 'tablespaces' not in context:
         context.tablespaces = {}
-    context.tablespaces[name] = Tablespace(name)
+    context.tablespaces[name] = Tablespace(name, with_desc=with_desc)
 
 
 @then('the tablespace is valid')
diff --git a/gpMgmt/test/behave_utils/utils.py b/gpMgmt/test/behave_utils/utils.py
index ec1039ab6a0..0df3e5da6f1 100644
--- a/gpMgmt/test/behave_utils/utils.py
+++ b/gpMgmt/test/behave_utils/utils.py
@@ -217,6 +217,22 @@ def stop_database_if_started(context):
 def stop_database(context):
     run_gpcommand(context, 'gpstop -M fast -a')
     if context.exception:
+        # Some gpinitsystem scenarios intentionally generate pg_hba.conf that
+        # blocks gpstop's coordinator connection. Fall back to local pg_ctl so
+        # later scenarios still start from a clean cluster.
+        stop_output = '%s\n%s' % (context.error_message or '', context.stdout_message or '')
+        if 'no pg_hba.conf entry' in stop_output:
+            coordinator_data_dir = get_coordinatordatadir()
+            subprocess.check_call([
+                'bash', '-lc',
+                'source %s/cloudberry-env.sh && pg_ctl stop -m fast -D %s' % (
+                    pipes.quote(os.environ.get("GPHOME")),
+                    pipes.quote(coordinator_data_dir),
+                )
+            ])
+            context.exception = None
+            context.ret_code = 0
+            return
         raise context.exception
 
 
diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c
index 63b4c323a61..28be3b44c72 100644
--- a/src/backend/access/transam/xlogrecovery.c
+++ b/src/backend/access/transam/xlogrecovery.c
@@ -4575,6 +4575,8 @@ SetPromoteIsTriggered(void)
 static bool
 CheckForStandbyTrigger(void)
 {
+	struct stat stat_buf;
+
 	if (LocalPromoteIsTriggered)
 		return true;
 
@@ -4587,6 +4589,30 @@ CheckForStandbyTrigger(void)
 		return true;
 	}
 
+	/*
+	 * Cloudberry retains the promote_trigger_file GUC (removed upstream in
+	 * PostgreSQL 16) because management utilities such as gpactivatestandby
+	 * rely on it to promote a standby coordinator that is started in utility
+	 * mode.  Honor the GUC here: the presence of the configured file ends
+	 * recovery, matching the documented behavior of the GUC.
+	 */
+	if (PromoteTriggerFile == NULL || strcmp(PromoteTriggerFile, "") == 0)
+		return false;
+
+	if (stat(PromoteTriggerFile, &stat_buf) == 0)
+	{
+		ereport(LOG,
+				(errmsg("promote trigger file found: %s", PromoteTriggerFile)));
+		unlink(PromoteTriggerFile);
+		SetPromoteIsTriggered();
+		return true;
+	}
+	else if (errno != ENOENT)
+		ereport(ERROR,
+				(errcode_for_file_access(),
+				 errmsg("could not stat promote trigger file \"%s\": %m",
+						PromoteTriggerFile)));
+
 	return false;
 }
 
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 12c8649b159..b00199abea1 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -5755,6 +5755,26 @@ process_pm_pmsignal(void)
 		if (recoveryTargetAction == RECOVERY_TARGET_ACTION_PROMOTE)
 			promotion_requested = true;
 
+		/*
+		 * GPDB: A configured promote_trigger_file whose file is already
+		 * present means a promotion is imminent (for example
+		 * gpactivatestandby's force path creates the trigger file before
+		 * starting the standby coordinator in utility mode).  Treat that the
+		 * same as an explicit promotion request so that, with hot standby
+		 * disabled, we do not prematurely report PM_STATUS_STANDBY.  Otherwise
+		 * "pg_ctl -w" would return as soon as recovery starts and the caller
+		 * (gpstart) would try to read the catalog before the server has
+		 * actually finished promoting and can accept connections.
+		 */
+		if (!promotion_requested &&
+			PromoteTriggerFile != NULL && PromoteTriggerFile[0] != '\0')
+		{
+			struct stat stat_buf;
+
+			if (stat(PromoteTriggerFile, &stat_buf) == 0)
+				promotion_requested = true;
+		}
+
 		/*
 		 * If we aren't planning to enter hot standby mode later, treat
 		 * RECOVERY_STARTED as meaning we're out of startup, and report status
diff --git a/src/bin/pg_basebackup/pg_basebackup.c b/src/bin/pg_basebackup/pg_basebackup.c
index 24cd2f05258..82d9f005008 100644
--- a/src/bin/pg_basebackup/pg_basebackup.c
+++ b/src/bin/pg_basebackup/pg_basebackup.c
@@ -1705,36 +1705,24 @@ get_tablespace_mapping(const char *dir)
 }
 
 static void
-add_to_exclude_list(PQExpBufferData *buf, const char *exclude)
+add_to_exclude_list(PQExpBuffer buf, bool use_new_option_syntax,
+					const char *exclude)
 {
-	char		quoted[MAXPGPATH];
-	int			error;
-	size_t		len;
-
-	error = 1;
-	len = PQescapeStringConn(conn, quoted, exclude, MAXPGPATH, &error);
-	if (len == 0 || error != 0)
-	{
-		pg_log_error("could not process exclude \"%s\": %s",
-					 exclude, PQerrorMessage(conn));
-		exit(1);
-	}
-	appendPQExpBuffer(buf, " EXCLUDE '%s'", quoted);
+	/*
+	 * EXCLUDE may be given more than once; the server collects every
+	 * occurrence into one hash table.
+	 */
+	AppendStringCommandOption(buf, use_new_option_syntax, "EXCLUDE",
+							  unconstify(char *, exclude));
 }
 
-static char *
-build_exclude_list(void)
+static void
+append_exclude_options(PQExpBuffer buf, bool use_new_option_syntax)
 {
-	PQExpBufferData	buf;
 	int				i;
 
-	if (num_exclude == 0 && num_exclude_from == 0)
-		return "";
-
-	initPQExpBuffer(&buf);
-
 	for (i = 0; i < num_exclude; i++)
-		add_to_exclude_list(&buf, excludes[i]);
+		add_to_exclude_list(buf, use_new_option_syntax, excludes[i]);
 
 	for (i = 0; i < num_exclude_from; i++)
 	{
@@ -1763,19 +1751,11 @@ build_exclude_list(void)
 				 len--)
 				str[len - 1] = '\0';
 
-			add_to_exclude_list(&buf, str);
+			add_to_exclude_list(buf, use_new_option_syntax, str);
 		}
 
 		fclose(file);
 	}
-
-	if (PQExpBufferDataBroken(buf))
-	{
-		pg_log_error("out of memory");
-		exit(1);
-	}
-
-	return buf.data;
 }
 
 /*
@@ -1850,7 +1830,6 @@ BaseBackup(char *compression_algorithm, char *compression_detail,
 	char		xlogend[64] = {0};
 	int			minServerMajor,
 				maxServerMajor;
-	char 	   *exclude_list;
 	int			serverVersion,
 				serverMajor;
 	int			writing_to_stdout;
@@ -1994,7 +1973,17 @@ BaseBackup(char *compression_algorithm, char *compression_detail,
 									  "COMPRESSION_DETAIL",
 									  compression_detail);
 	}
-	exclude_list = build_exclude_list();
+	append_exclude_options(&buf, use_new_option_syntax);
+
+	/*
+	 * The append helpers do not exit on allocation failure; they mark the
+	 * buffer broken, which empties it and turns later appends into no-ops.
+	 * Without this check an out-of-memory would send a BASE_BACKUP carrying
+	 * none of the options built above -- including the EXCLUDEs -- instead of
+	 * failing.
+	 */
+	if (PQExpBufferDataBroken(buf))
+		pg_fatal("out of memory");
 
 	if (verbose)
 		pg_log_info("initiating base backup, waiting for checkpoint to complete");
@@ -2008,9 +1997,6 @@ BaseBackup(char *compression_algorithm, char *compression_detail,
 			fprintf(stderr, "\n");
 	}
 
-	if (exclude_list[0] != '\0')
-		free(exclude_list);
-
 	if (use_new_option_syntax && buf.len > 0)
 		basebkp = psprintf("BASE_BACKUP (%s)", buf.data);
 	else
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index b024acaf768..127ae5574a0 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -2191,8 +2191,11 @@ selectDumpableType(TypeInfo *tyinfo, Archive *fout)
  *		Mark a function as to be dumped or not
  */
 static void
-selectDumpableFunction(FuncInfo *finfo)
+selectDumpableFunction(FuncInfo *finfo, Archive *fout)
 {
+	if (checkExtensionMembership(&finfo->dobj, fout))
+		return;					/* extension membership overrides all else */
+
 	/*
 	 * If specific functions are being dumped, dump just those functions; else, dump
 	 * according to the parent namespace's dump flag if parent namespace is not null;
@@ -2200,11 +2203,12 @@ selectDumpableFunction(FuncInfo *finfo)
 	 */
 	if (function_include_oids.head != NULL)
 		finfo->dobj.dump = simple_oid_list_member(&function_include_oids,
-												   finfo->dobj.catId.oid);
+												  finfo->dobj.catId.oid) ?
+			DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
 	else if (finfo->dobj.namespace)
-		finfo->dobj.dump = finfo->dobj.namespace->dobj.dump;
+		finfo->dobj.dump = finfo->dobj.namespace->dobj.dump_contains;
 	else
-		finfo->dobj.dump = true;
+		finfo->dobj.dump = DUMP_COMPONENT_ALL;
 }
 
 /*
@@ -7299,8 +7303,7 @@ getFuncs(Archive *fout, int *numFuncs)
 		finfo[i].postponed_def = false; /* might get set during sort */
 
 		/* Decide whether we want to dump it */
-		selectDumpableFunction(&finfo[i]);
-		selectDumpableObject(&(finfo[i].dobj), fout);
+		selectDumpableFunction(&finfo[i], fout);
 
 		/* Mark whether function has an ACL */
 		if (!PQgetisnull(res, i, i_proacl))
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index e0ee7930046..6ceae687e69 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -10,6 +10,7 @@
 #include "postgres_fe.h"
 #include <sys/stat.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <time.h>
 #include <unistd.h>
 
@@ -368,16 +369,34 @@ main(int argc, char **argv)
 
 #ifdef FAULT_INJECTOR
 	/*
-	 * SUSPEND_PG_REWIND is used for testing purposes. If set to true, the pg_rewind process will be
-	 * suspended for 120 seconds, so that it's entry can be checked in the pg_stat_activity table.
+	 * SUSPEND_PG_REWIND is used for testing purposes. If set to an int, the pg_rewind process will be
+	 * suspended for set amount of time(secs), so that it's entry can be checked in the pg_stat_activity table.
 	 * The goal being that we can run another instance of gprecoverseg and assert that it ignores
 	 * recovery for segments that already have an active pg_rewind process.
 	 */
 	char* suspend_pg_rewind = getenv("SUSPEND_PG_REWIND");
-	if(suspend_pg_rewind != NULL && strcmp(suspend_pg_rewind, "true") == 0)
+	if(suspend_pg_rewind != NULL)
 	{
-		pg_log_info("pg_rewind suspended");
-		sleep(120);
+		char	   *end;
+		long		secs;
+
+		/*
+		 * Not atoi(): it reports 0 for anything it cannot parse. This
+		 * variable used to be the literal string "true", so a caller that
+		 * has not caught up would get a silent no-op and then a timeout in
+		 * whatever was waiting to observe the suspended process -- with
+		 * nothing anywhere saying why. A negative value is worse: sleep()
+		 * takes an unsigned int, so -1 becomes a sleep of some decades.
+		 */
+		errno = 0;
+		secs = strtol(suspend_pg_rewind, &end, 10);
+		if (*suspend_pg_rewind == '\0' || *end != '\0' ||
+			errno != 0 || secs < 0 || secs > INT_MAX)
+			pg_fatal("SUSPEND_PG_REWIND must be a non-negative number of seconds, not \"%s\"",
+					 suspend_pg_rewind);
+
+		pg_log_info("pg_rewind suspended for %ld seconds", secs);
+		sleep((unsigned int) secs);
 	}
 #endif