.cirrus.tasks.yml

# CI configuration file for CI utilizing cirrus-ci.org
#
# For instructions on how to enable the CI integration in a repository and
# further details, see src/tools/ci/README
#
#
# NB: Different tasks intentionally test with different, non-default,
# configurations, to increase the chance of catching problems. Each task with
# non-obvious non-default documents their oddity at the top of the task,
# prefixed by "SPECIAL:".


env:
  # The lower depth accelerates git clone. Use a bit of depth so that
  # concurrent tasks and retrying older jobs have a chance of working.
  CIRRUS_CLONE_DEPTH: 500
  # Useful to be able to analyse what in a script takes long
  CIRRUS_LOG_TIMESTAMP: true

  CCACHE_MAXSIZE: "250M"

  # target to test, for all but windows
  CHECK: check-world PROVE_FLAGS=$PROVE_FLAGS
  CHECKFLAGS: -Otarget
  PROVE_FLAGS: --timer
  # Build test dependencies as part of the build step, to see compiler
  # errors/warnings in one place.
  MBUILD_TARGET: all testprep
  MTEST_ARGS: --print-errorlogs --no-rebuild -C build
  PGCTLTIMEOUT: 120 # avoids spurious failures during parallel tests
  TEMP_CONFIG: ${CIRRUS_WORKING_DIR}/src/tools/ci/pg_ci_base.conf
  PG_TEST_EXTRA: kerberos ldap ssl libpq_encryption load_balance oauth

  # Postgres config args for the meson builds, shared between all meson tasks
  # except the 'SanityCheck' task
  MESON_COMMON_PG_CONFIG_ARGS: -Dcassert=true -Dinjection_points=true

  # Meson feature flags shared by all meson tasks, except:
  # SanityCheck: uses almost no dependencies.
  # Windows - VS: has fewer dependencies than listed here, so defines its own.
  # Linux: uses the 'auto' feature option to test meson feature autodetection.
  MESON_COMMON_FEATURES: >-
    -Dauto_features=disabled
    -Dldap=enabled
    -Dssl=openssl
    -Dtap_tests=enabled
    -Dplperl=enabled
    -Dplpython=enabled
    -Ddocs=enabled
    -Dicu=enabled
    -Dlibxml=enabled
    -Dlibxslt=enabled
    -Dlz4=enabled
    -Dpltcl=enabled
    -Dreadline=enabled
    -Dzlib=enabled
    -Dzstd=enabled


# What files to preserve in case tests fail
on_failure_ac: &on_failure_ac
  log_artifacts:
    paths:
      - "**/*.log"
      - "**/*.diffs"
      - "**/regress_log_*"
    type: text/plain

on_failure_meson: &on_failure_meson
  testrun_artifacts:
    paths:
      - "build*/testrun/**/*.log"
      - "build*/testrun/**/*.diffs"
      - "build*/testrun/**/regress_log_*"
    type: text/plain

  # In theory it'd be nice to upload the junit files meson generates, so that
  # cirrus will nicely annotate the commit. Unfortunately the files don't
  # contain identifiable file + line numbers right now, so the annotations
  # don't end up useful. We could probably improve on that with a some custom
  # conversion script, but ...
  meson_log_artifacts:
    path: "build*/meson-logs/*.txt"
    type: text/plain


# To avoid unnecessarily spinning up a lot of VMs / containers for entirely
# broken commits, have a minimal task that all others depend on.
#
# SPECIAL:
# - Builds with --auto-features=disabled and thus almost no enabled
#   dependencies
task:
  name: SanityCheck

  # If a specific OS is requested, don't run the sanity check. This shortens
  # push-wait-for-ci cycle time a bit when debugging operating system specific
  # failures. Uses skip instead of only_if, as cirrus otherwise warns about
  # only_if conditions not matching.
  skip: $CI_SANITYCHECK_ENABLED == false

  env:
    CPUS: 4
    BUILD_JOBS: 8
    TEST_JOBS: 8
    IMAGE_FAMILY: pg-ci-trixie
    CCACHE_DIR: ${CIRRUS_WORKING_DIR}/ccache_dir
    # no options enabled, should be small
    CCACHE_MAXSIZE: "150M"

  # While containers would start up a bit quicker, building is a bit
  # slower. This way we don't have to maintain a container image.
  <<: *linux_task_template

  ccache_cache:
    folder: $CCACHE_DIR

  create_user_script: |
    useradd -m postgres
    chown -R postgres:postgres .
    mkdir -p ${CCACHE_DIR}
    chown -R postgres:postgres ${CCACHE_DIR}
    echo '* - memlock 134217728' > /etc/security/limits.d/postgres.conf
    su postgres -c "ulimit -l -H && ulimit -l -S"
    # Can't change container's kernel.core_pattern. Postgres user can't write
    # to / normally. Change that.
    chown root:postgres /
    chmod g+rwx /

  configure_script: |
    su postgres <<-EOF
      set -e
      meson setup \
        --buildtype=debug \
        --auto-features=disabled \
        -Dtap_tests=enabled \
        build
    EOF
  build_script: |
    su postgres <<-EOF
      set -e
      ninja -C build -j${BUILD_JOBS} ${MBUILD_TARGET}
    EOF
  upload_caches: ccache

  # Run a minimal set of tests. The main regression tests take too long for
  # this purpose. For now this is a random quick pg_regress style test, and a
  # tap test that exercises both a frontend binary and the backend.
  test_minimal_script: |
    su postgres <<-EOF
      set -e
      ulimit -c unlimited
      meson test $MTEST_ARGS --suite setup
      meson test $MTEST_ARGS --num-processes ${TEST_JOBS} \
        cube/regress pg_ctl/001_start_stop
    EOF

  on_failure:
    <<: *on_failure_meson
    cores_script: |
      mkdir -m 770 /tmp/cores
      find / -maxdepth 1 -type f -name 'core*' -exec mv '{}' /tmp/cores/ \;
      src/tools/ci/cores_backtrace.sh linux /tmp/cores


# SPECIAL:
# - Uses postgres specific CPPFLAGS that increase test coverage
# - Specifies configuration options that test reading/writing/copying of node trees
# - Specifies debug_parallel_query=regress, to catch related issues during CI
# - Also runs tests against a running postgres instance, see test_running_script
task:
  name: FreeBSD - Meson

  env:
    CPUS: 4
    BUILD_JOBS: 4
    TEST_JOBS: 8
    IMAGE_FAMILY: pg-ci-freebsd
    DISK_SIZE: 50

    CCACHE_DIR: /tmp/ccache_dir
    CPPFLAGS: -DRELCACHE_FORCE_RELEASE -DENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
    CFLAGS: -Og -ggdb

    # Several buildfarm animals enable these options. Without testing them
    # during CI, it would be easy to cause breakage on the buildfarm with CI
    # passing.
    PG_TEST_INITDB_EXTRA_OPTS: >-
      -c debug_copy_parse_plan_trees=on
      -c debug_write_read_parse_plan_trees=on
      -c debug_raw_expression_coverage_test=on
      -c debug_parallel_query=regress
    PG_TEST_PG_UPGRADE_MODE: --link

    MESON_FEATURES: >-
      -Ddtrace=enabled
      -Dgssapi=enabled
      -Dlibcurl=enabled
      -Dnls=enabled
      -Dpam=enabled
      -Dtcl_version=tcl86
      -Duuid=bsd

  <<: *freebsd_task_template

  depends_on: SanityCheck
  only_if: $CI_FREEBSD_ENABLED

  sysinfo_script: |
    id
    uname -a
    ulimit -a -H && ulimit -a -S
    export

  ccache_cache:
    folder: $CCACHE_DIR
  setup_ram_disk_script: src/tools/ci/gcp_ram_disk.sh
  create_user_script: |
    pw useradd postgres
    chown -R postgres:postgres .
    mkdir -p ${CCACHE_DIR}
    chown -R postgres:postgres ${CCACHE_DIR}
  setup_core_files_script: |
    mkdir -m 770 /tmp/cores
    chown root:postgres /tmp/cores
    sysctl kern.corefile='/tmp/cores/%N.%P.core'
  setup_additional_packages_script: |
    #pkg install -y ...

  # NB: Intentionally build without -Dllvm. The freebsd image size is already
  # large enough to make VM startup slow, and even without llvm freebsd
  # already takes longer than other platforms except for windows.
  configure_script: |
    su postgres <<-EOF
      set -e
      meson setup \
        ${MESON_COMMON_PG_CONFIG_ARGS} \
        --buildtype=debug \
        -Dextra_lib_dirs=/usr/local/lib -Dextra_include_dirs=/usr/local/include/ \
        ${MESON_COMMON_FEATURES} ${MESON_FEATURES} \
        build
    EOF
  build_script: su postgres -c 'ninja -C build -j${BUILD_JOBS} ${MBUILD_TARGET}'
  upload_caches: ccache

  test_world_script: |
    su postgres <<-EOF
      set -e
      ulimit -c unlimited
      meson test $MTEST_ARGS --num-processes ${TEST_JOBS}
    EOF

  # test runningcheck, freebsd chosen because it's currently fast enough
  test_running_script: |
    su postgres <<-EOF
      set -e
      ulimit -c unlimited
      meson test $MTEST_ARGS --quiet --suite setup
      export LD_LIBRARY_PATH="$(pwd)/build/tmp_install/usr/local/pgsql/lib/:$LD_LIBRARY_PATH"
      mkdir -p build/testrun
      build/tmp_install/usr/local/pgsql/bin/initdb -N build/runningcheck --no-instructions -A trust
      echo "include '$(pwd)/src/tools/ci/pg_ci_base.conf'" >> build/runningcheck/postgresql.conf
      build/tmp_install/usr/local/pgsql/bin/pg_ctl -c -o '-c fsync=off' -D build/runningcheck -l build/testrun/runningcheck.log start
      meson test $MTEST_ARGS --num-processes ${TEST_JOBS} --setup running
      build/tmp_install/usr/local/pgsql/bin/pg_ctl -D build/runningcheck stop
    EOF

  on_failure:
    # if the server continues running, it often causes cirrus-ci to fail
    # during upload, as it doesn't expect artifacts to change size
    stop_running_script: |
      su postgres <<-EOF
        set -e
        build/tmp_install/usr/local/pgsql/bin/pg_ctl -D build/runningcheck stop || true
      EOF
    <<: *on_failure_meson
    cores_script: src/tools/ci/cores_backtrace.sh freebsd /tmp/cores


task:
  depends_on: SanityCheck

  env:
    # Below are experimentally derived to be a decent choice.
    CPUS: 4
    BUILD_JOBS: 8
    TEST_JOBS: 8

    # Default working directory is /tmp, but its total size (1.2 GB) is not
    # enough, so different working and cache directory are set.
    CIRRUS_WORKING_DIR: /home/postgres/postgres
    CCACHE_DIR: /home/postgres/cache

    PATH: /usr/sbin:$PATH
    CORE_DUMP_DIR: /var/crash

  matrix:
    - name: NetBSD - Meson
      # See REPO_CI_AUTOMATIC_TRIGGER_TASKS in .cirrus.star
      trigger_type: $CI_TRIGGER_TYPE_NETBSD
      only_if: $CI_NETBSD_ENABLED
      env:
        OS_NAME: netbsd
        IMAGE_FAMILY: pg-ci-netbsd-postgres
        PKGCONFIG_PATH: '/usr/lib/pkgconfig:/usr/pkg/lib/pkgconfig'
        # initdb fails with: 'invalid locale settings' error on NetBSD.
        # Force 'LANG' and 'LC_*' variables to be 'C'.
        # See https://postgr.es/m/2490325.1734471752%40sss.pgh.pa.us
        LANG: "C"
        LC_ALL: "C"
        # -Duuid is not set for the NetBSD, see the comment below, above
        # configure_script, for more information.
        MESON_FEATURES: >-
          -Dgssapi=enabled
          -Dlibcurl=enabled
          -Dnls=enabled
          -Dpam=enabled

      setup_additional_packages_script: |
        #pkgin -y install ...
      <<: *netbsd_task_template

    - name: OpenBSD - Meson
      # See REPO_CI_AUTOMATIC_TRIGGER_TASKS in .cirrus.star
      trigger_type: $CI_TRIGGER_TYPE_OPENBSD
      only_if: $CI_OPENBSD_ENABLED
      env:
        OS_NAME: openbsd
        IMAGE_FAMILY: pg-ci-openbsd-postgres
        PKGCONFIG_PATH: '/usr/lib/pkgconfig:/usr/local/lib/pkgconfig'
        CORE_DUMP_EXECUTABLE_DIR: $CIRRUS_WORKING_DIR/build/tmp_install/usr/local/pgsql/bin

        MESON_FEATURES: >-
          -Dbsd_auth=enabled
          -Dlibcurl=enabled
          -Dtcl_version=tcl86
          -Duuid=e2fs

      setup_additional_packages_script: |
        #pkg_add -I ...
      # Always core dump to ${CORE_DUMP_DIR}
      set_core_dump_script: sysctl -w kern.nosuidcoredump=2
      <<: *openbsd_task_template

  sysinfo_script: |
    locale
    id
    uname -a
    ulimit -a -H && ulimit -a -S
    env

  ccache_cache:
    folder: $CCACHE_DIR
  setup_ram_disk_script: src/tools/ci/gcp_ram_disk.sh
  create_user_script: |
    useradd postgres
    chown -R postgres:users /home/postgres
    mkdir -p ${CCACHE_DIR}
    chown -R postgres:users ${CCACHE_DIR}
  setup_core_files_script: |
    mkdir -p ${CORE_DUMP_DIR}
    chmod -R 770 ${CORE_DUMP_DIR}
    chown -R postgres:users ${CORE_DUMP_DIR}

  # -Duuid=bsd is not set since 'bsd' uuid option
  # is not working on NetBSD & OpenBSD. See
  # https://www.postgresql.org/message-id/17358-89806e7420797025@postgresql.org
  # And other uuid options are not available on NetBSD.
  configure_script: |
    su postgres <<-EOF
      set -e
      meson setup \
        ${MESON_COMMON_PG_CONFIG_ARGS} \
        --buildtype=debugoptimized \
        --pkg-config-path ${PKGCONFIG_PATH} \
        ${MESON_COMMON_FEATURES} ${MESON_FEATURES} \
        build
    EOF

  build_script: su postgres -c 'ninja -C build -j${BUILD_JOBS} ${MBUILD_TARGET}'
  upload_caches: ccache

  test_world_script: |
    su postgres <<-EOF
      set -e
      ulimit -c unlimited
      meson test $MTEST_ARGS --num-processes ${TEST_JOBS}
    EOF

  on_failure:
    <<: *on_failure_meson
    cores_script: |
      # Although we try to configure the OS to core dump inside
      # ${CORE_DUMP_DIR}, they may not obey this. So, move core files to the
      # ${CORE_DUMP_DIR} directory.
      find build/ -type f -name '*.core' -exec mv '{}' ${CORE_DUMP_DIR} \;
      src/tools/ci/cores_backtrace.sh ${OS_NAME} ${CORE_DUMP_DIR} ${CORE_DUMP_EXECUTABLE_DIR}


# configure feature flags, shared between the task running the linux tests and
# the CompilerWarnings task
LINUX_CONFIGURE_FEATURES: &LINUX_CONFIGURE_FEATURES >-
  --with-gssapi
  --with-icu
  --with-ldap
  --with-libcurl
  --with-libxml
  --with-libxslt
  --with-llvm
  --with-lz4
  --with-pam
  --with-perl
  --with-python
  --with-selinux
  --with-ssl=openssl
  --with-systemd
  --with-tcl --with-tclconfig=/usr/lib/tcl8.6/
  --with-uuid=ossp
  --with-zstd


# Check SPECIAL in the matrix: below
task:
  env:
    CPUS: 4
    BUILD_JOBS: 4
    TEST_JOBS: 8 # experimentally derived to be a decent choice
    IMAGE_FAMILY: pg-ci-trixie

    CCACHE_DIR: /tmp/ccache_dir
    DEBUGINFOD_URLS: "https://debuginfod.debian.net"

    # Enable a reasonable set of sanitizers. Use the linux task for that, as
    # it's one of the fastest tasks (without sanitizers). Also several of the
    # sanitizers work best on linux.
    #
    # The overhead of alignment sanitizer is low, undefined behaviour has
    # moderate overhead. Test alignment sanitizer in the meson task, as it
    # does both 32 and 64 bit builds and is thus more likely to expose
    # alignment bugs.
    #
    # Address sanitizer in contrast is somewhat expensive. Enable it in the
    # autoconf task, as the meson task tests both 32 and 64bit.
    #
    # disable_coredump=0, abort_on_error=1: for useful backtraces in case of crashes
    # print_stacktraces=1,verbosity=2, duh
    # detect_leaks=0: too many uninteresting leak errors in short-lived binaries
    UBSAN_OPTIONS: print_stacktrace=1:disable_coredump=0:abort_on_error=1:verbosity=2
    ASAN_OPTIONS: print_stacktrace=1:disable_coredump=0:abort_on_error=1:detect_leaks=0:detect_stack_use_after_return=0

    # SANITIZER_FLAGS is set in the tasks below
    CFLAGS: -Og -ggdb -fno-sanitize-recover=all $SANITIZER_FLAGS
    CXXFLAGS: $CFLAGS
    LDFLAGS: $SANITIZER_FLAGS
    CC: ccache gcc
    CXX: ccache g++

    LINUX_CONFIGURE_FEATURES: *LINUX_CONFIGURE_FEATURES
    LINUX_MESON_FEATURES: >-
      -Duuid=e2fs

  <<: *linux_task_template

  depends_on: SanityCheck
  only_if: $CI_LINUX_ENABLED

  ccache_cache:
    folder: ${CCACHE_DIR}

  sysinfo_script: |
    id
    uname -a
    cat /proc/cmdline
    ulimit -a -H && ulimit -a -S
    export
  create_user_script: |
    useradd -m postgres
    chown -R postgres:postgres .
    mkdir -p ${CCACHE_DIR}
    chown -R postgres:postgres ${CCACHE_DIR}
    echo '* - memlock 134217728' > /etc/security/limits.d/postgres.conf
    su postgres -c "ulimit -l -H && ulimit -l -S"
  setup_core_files_script: |
    mkdir -m 770 /tmp/cores
    chown root:postgres /tmp/cores
    sysctl kernel.core_pattern='/tmp/cores/%e-%s-%p.core'

  setup_hosts_file_script: |
    cat >> /etc/hosts <<-EOF
      127.0.0.1 pg-loadbalancetest
      127.0.0.2 pg-loadbalancetest
      127.0.0.3 pg-loadbalancetest
    EOF

  setup_additional_packages_script: |
    #apt-get update
    #DEBIAN_FRONTEND=noninteractive apt-get -y install ...

  matrix:
    # SPECIAL:
    # - Uses address sanitizer, sanitizer failures are typically printed in
    #   the server log
    # - Configures postgres with a small segment size
    - name: Linux - Debian Trixie - Autoconf

      env:
        SANITIZER_FLAGS: -fsanitize=address
        PG_TEST_PG_COMBINEBACKUP_MODE: --copy-file-range

      # Normally, the "relation segment" code basically has no coverage in our
      # tests, because we (quite reasonably) don't generate tables large
      # enough in tests. We've had plenty bugs that we didn't notice due the
      # code not being exercised much. Thus specify a very small segment size
      # here. Use a non-power-of-two segment size, given we currently allow
      # that.
      configure_script: |
        su postgres <<-EOF
          set -e
          ./configure \
            --enable-cassert --enable-injection-points --enable-debug \
            --enable-tap-tests --enable-nls \
            --with-segsize-blocks=6 \
            --with-libnuma \
            --with-liburing \
            \
            ${LINUX_CONFIGURE_FEATURES} \
            \
            CLANG="ccache clang"
        EOF
      build_script: su postgres -c "make -s -j${BUILD_JOBS} world-bin"
      upload_caches: ccache

      test_world_script: |
        su postgres <<-EOF
          set -e
          ulimit -c unlimited # default is 0
          make -s ${CHECK} ${CHECKFLAGS} -j${TEST_JOBS}
        EOF

      on_failure:
        <<: *on_failure_ac

    # SPECIAL:
    # - Uses undefined behaviour and alignment sanitizers, sanitizer failures
    #   are typically printed in the server log
    # - Test both 64bit and 32 bit builds
    # - uses io_method=io_uring
    # - Uses meson feature autodetection
    - name: Linux - Debian Trixie - Meson

      env:
        CCACHE_MAXSIZE: "400M" # tests two different builds
        SANITIZER_FLAGS: -fsanitize=alignment,undefined
        PG_TEST_INITDB_EXTRA_OPTS: >-
          -c io_method=io_uring

      configure_script: |
        su postgres <<-EOF
          set -e
          meson setup \
            ${MESON_COMMON_PG_CONFIG_ARGS} \
            --buildtype=debug \
            ${LINUX_MESON_FEATURES} -Dllvm=enabled \
            build
        EOF

      # Also build & test in a 32bit build - it's gotten rare to test that
      # locally.
      configure_32_script: |
        su postgres <<-EOF
          set -e
          export CC='ccache gcc -m32'
          export CXX='ccache g++ -m32'
          meson setup \
            ${MESON_COMMON_PG_CONFIG_ARGS} \
            --buildtype=debug \
            --pkg-config-path /usr/lib/i386-linux-gnu/pkgconfig/ \
            -DPERL=perl5.40-i386-linux-gnu \
            ${LINUX_MESON_FEATURES} -Dlibnuma=disabled \
            build-32
        EOF

      build_script: |
        su postgres <<-EOF
          set -e
          ninja -C build -j${BUILD_JOBS} ${MBUILD_TARGET}
          ninja -C build -t missingdeps
        EOF

      build_32_script: |
        su postgres <<-EOF
          set -e
          ninja -C build-32 -j${BUILD_JOBS} ${MBUILD_TARGET}
          ninja -C build -t missingdeps
        EOF

      upload_caches: ccache

      test_world_script: |
        su postgres <<-EOF
          set -e
          ulimit -c unlimited
          meson test $MTEST_ARGS --num-processes ${TEST_JOBS}
        EOF
        # so that we don't upload 64bit logs if 32bit fails
        rm -rf build/

      # There's currently no coverage of icu with LANG=C in the buildfarm. We
      # can easily provide some here by running one of the sets of tests that
      # way. Newer versions of python insist on changing the LC_CTYPE away
      # from C, prevent that with PYTHONCOERCECLOCALE.
      test_world_32_script: |
        su postgres <<-EOF
          set -e
          ulimit -c unlimited
          PYTHONCOERCECLOCALE=0 LANG=C meson test $MTEST_ARGS -C build-32 --num-processes ${TEST_JOBS}
        EOF

      on_failure:
        <<: *on_failure_meson

  on_failure:
    cores_script: src/tools/ci/cores_backtrace.sh linux /tmp/cores


# NB: macOS is by far the most expensive OS to run CI for, therefore no
# expensive additional checks should be added.
#
# SPECIAL:
# - Enables --clone for pg_upgrade and pg_combinebackup
task:
  name: macOS - Sequoia - Meson

  env:
    CPUS: 4 # always get that much for cirrusci macOS instances
    BUILD_JOBS: $CPUS
    # Test performance regresses noticeably when using all cores. 8 seems to
    # work OK. See
    # https://postgr.es/m/20220927040208.l3shfcidovpzqxfh%40awork3.anarazel.de
    TEST_JOBS: 8
    IMAGE: ghcr.io/cirruslabs/macos-runner:sequoia

    CIRRUS_WORKING_DIR: ${HOME}/pgsql/
    CCACHE_DIR: ${HOME}/ccache
    MACPORTS_CACHE: ${HOME}/macports-cache

    MESON_FEATURES: >-
      -Dbonjour=enabled
      -Ddtrace=enabled
      -Dgssapi=enabled
      -Dlibcurl=enabled
      -Dnls=enabled
      -Duuid=e2fs

    MACOS_PACKAGE_LIST: >-
      ccache
      icu
      kerberos5
      lz4
      meson
      openldap
      openssl
      p5.34-io-tty
      p5.34-ipc-run
      python312
      tcl
      zstd

    CC: ccache cc
    CXX: ccache c++
    CFLAGS: -Og -ggdb
    CXXFLAGS: -Og -ggdb

    PG_TEST_PG_UPGRADE_MODE: --clone
    PG_TEST_PG_COMBINEBACKUP_MODE: --clone

  <<: *macos_task_template

  depends_on: SanityCheck
  only_if: $CI_MACOS_ENABLED

  sysinfo_script: |
    id
    uname -a
    ulimit -a -H && ulimit -a -S
    export

  setup_core_files_script:
    - mkdir ${HOME}/cores
    - sudo sysctl kern.corefile="${HOME}/cores/core.%P"

  # Use macports, even though homebrew is installed. The installation
  # of the additional packages we need would take quite a while with
  # homebrew, even if we cache the downloads. We can't cache all of
  # homebrew, because it's already large. So we use macports. To cache
  # the installation we create a .dmg file that we mount if it already
  # exists.
  # XXX: The reason for the direct p5.34* references is that we'd need
  # the large macport tree around to figure out that p5-io-tty is
  # actually p5.34-io-tty. Using the unversioned name works, but
  # updates macports every time.
  macports_cache:
    folder: ${MACPORTS_CACHE}
    fingerprint_script: |
      # Reinstall packages if the OS major version, the list of the packages
      # to install or the MacPorts install script changes.
      sw_vers -productVersion | sed 's/\..*//'
      echo $MACOS_PACKAGE_LIST
      md5 src/tools/ci/ci_macports_packages.sh
    reupload_on_changes: true
  setup_additional_packages_script: |
    sh src/tools/ci/ci_macports_packages.sh $MACOS_PACKAGE_LIST
    # system python doesn't provide headers
    sudo /opt/local/bin/port select python3 python312
    # Make macports install visible for subsequent steps
    echo PATH=/opt/local/sbin/:/opt/local/bin/:$PATH >> $CIRRUS_ENV
  upload_caches: macports

  ccache_cache:
    folder: $CCACHE_DIR
  configure_script: |
    export PKG_CONFIG_PATH="/opt/local/lib/pkgconfig/"
    meson setup \
      ${MESON_COMMON_PG_CONFIG_ARGS} \
      --buildtype=debug \
      -Dextra_include_dirs=/opt/local/include \
      -Dextra_lib_dirs=/opt/local/lib \
      ${MESON_COMMON_FEATURES} ${MESON_FEATURES} \
      build

  build_script: ninja -C build -j${BUILD_JOBS} ${MBUILD_TARGET}
  upload_caches: ccache

  test_world_script: |
    ulimit -c unlimited # default is 0
    ulimit -n 1024 # default is 256, pretty low
    meson test $MTEST_ARGS --num-processes ${TEST_JOBS}

  on_failure:
    <<: *on_failure_meson
    cores_script: src/tools/ci/cores_backtrace.sh macos "${HOME}/cores"


WINDOWS_ENVIRONMENT_BASE: &WINDOWS_ENVIRONMENT_BASE
  env:
    # Half the allowed per-user CPU cores
    CPUS: 4

    # The default cirrus working dir is in a directory msbuild complains about
    CIRRUS_WORKING_DIR: "c:/cirrus"
    # git's tar doesn't deal with drive letters, see
    # https://postgr.es/m/b6782dc3-a7b0-ed56-175f-f8f54cb08d67%40dunslane.net
    TAR: "c:/windows/system32/tar.exe"
    # Avoids port conflicts between concurrent tap test runs
    PG_TEST_USE_UNIX_SOCKETS: 1
    PG_REGRESS_SOCK_DIR: "c:/cirrus/"
    DISK_SIZE: 50
    IMAGE_FAMILY: pg-ci-windows-ci

  sysinfo_script: |
    chcp
    systeminfo
    powershell -Command get-psdrive -psprovider filesystem
    set


task:
  name: Windows - Server 2022, VS 2019 - Meson & ninja
  << : *WINDOWS_ENVIRONMENT_BASE

  env:
    TEST_JOBS: 8 # wild guess, data based value welcome

    # Cirrus defaults to SetErrorMode(SEM_NOGPFAULTERRORBOX | ...). That
    # prevents crash reporting from working unless binaries do SetErrorMode()
    # themselves. Furthermore, it appears that either python or, more likely,
    # the C runtime has a bug where SEM_NOGPFAULTERRORBOX can very
    # occasionally *trigger* a crash on process exit - which is hard to debug,
    # given that it explicitly prevents crash dumps from working...
    # 0x8001 is SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX
    CIRRUS_WINDOWS_ERROR_MODE: 0x8001

    MESON_FEATURES:
      -Dauto_features=disabled
      -Dldap=enabled
      -Dssl=openssl
      -Dtap_tests=enabled
      -Dplperl=enabled
      -Dplpython=enabled

  <<: *windows_task_template

  depends_on: SanityCheck
  only_if: $CI_WINDOWS_ENABLED

  setup_additional_packages_script: |
    REM choco install -y --no-progress ...

  setup_hosts_file_script: |
    echo 127.0.0.1 pg-loadbalancetest >> c:\Windows\System32\Drivers\etc\hosts
    echo 127.0.0.2 pg-loadbalancetest >> c:\Windows\System32\Drivers\etc\hosts
    echo 127.0.0.3 pg-loadbalancetest >> c:\Windows\System32\Drivers\etc\hosts
    type c:\Windows\System32\Drivers\etc\hosts

  configure_script: |
    vcvarsall x64
    meson setup --backend ninja %MESON_COMMON_PG_CONFIG_ARGS% --buildtype debug -Db_pch=true -Dextra_lib_dirs=c:\openssl\1.1\lib -Dextra_include_dirs=c:\openssl\1.1\include -DTAR=%TAR% %MESON_FEATURES% build

  build_script: |
    vcvarsall x64
    ninja -C build %MBUILD_TARGET%
    ninja -C build -t missingdeps

  check_world_script: |
    vcvarsall x64
    meson test %MTEST_ARGS% --num-processes %TEST_JOBS%

  on_failure:
    <<: *on_failure_meson
    crashlog_artifacts:
      path: "crashlog-*.txt"
      type: text/plain


task:
  << : *WINDOWS_ENVIRONMENT_BASE
  name: Windows - Server 2022, MinGW64 - Meson

  # See REPO_CI_AUTOMATIC_TRIGGER_TASKS in .cirrus.star.
  trigger_type: $CI_TRIGGER_TYPE_MINGW

  depends_on: SanityCheck
  only_if: $CI_MINGW_ENABLED

  env:
    TEST_JOBS: 4 # higher concurrency causes occasional failures
    CCACHE_DIR: C:/msys64/ccache
    CCACHE_MAXSIZE: "500M"
    CCACHE_SLOPPINESS: pch_defines,time_macros
    CCACHE_DEPEND: 1
    # for some reason mingw plpython cannot find its installation without this
    PYTHONHOME: C:/msys64/ucrt64
    # prevents MSYS bash from resetting error mode
    MSYS: winjitdebug
    # Start bash in current working directory
    CHERE_INVOKING: 1
    BASH: C:\msys64\usr\bin\bash.exe -l

    # Keep -Dnls explicitly disabled, as the number of files it creates causes a
    # noticeable slowdown.
    MESON_FEATURES: >-
      -Dnls=disabled

  <<: *windows_task_template

  ccache_cache:
    folder: ${CCACHE_DIR}

  setup_additional_packages_script: |
    REM C:\msys64\usr\bin\pacman.exe -S --noconfirm ...

  mingw_info_script: |
    %BASH% -c "where gcc"
    %BASH% -c "gcc --version"
    %BASH% -c "where perl"
    %BASH% -c "perl --version"

  configure_script: |
    %BASH% -c "meson setup %MESON_COMMON_PG_CONFIG_ARGS% -Ddebug=true -Doptimization=g -Db_pch=true %MESON_COMMON_FEATURES% %MESON_FEATURES% -DTAR=%TAR% build"

  build_script: |
    %BASH% -c "ninja -C build ${MBUILD_TARGET}"

  upload_caches: ccache

  test_world_script: |
    %BASH% -c "meson test %MTEST_ARGS% --num-processes %TEST_JOBS%"

  on_failure:
    <<: *on_failure_meson
    crashlog_artifacts:
      path: "crashlog-*.txt"
      type: text/plain


task:
  name: CompilerWarnings

  # To limit unnecessary work only run this once the SanityCheck
  # succeeds. This is particularly important for this task as we intentionally
  # use always: to continue after failures.
  depends_on: SanityCheck
  only_if: $CI_COMPILERWARNINGS_ENABLED

  env:
    CPUS: 4
    BUILD_JOBS: 4
    IMAGE_FAMILY: pg-ci-trixie

    # Use larger ccache cache, as this task compiles with multiple compilers /
    # flag combinations
    CCACHE_MAXSIZE: "1G"
    CCACHE_DIR: "/tmp/ccache_dir"

    LINUX_CONFIGURE_FEATURES: *LINUX_CONFIGURE_FEATURES

  <<: *linux_task_template

  sysinfo_script: |
    id
    uname -a
    cat /proc/cmdline
    ulimit -a -H && ulimit -a -S
    gcc -v
    clang -v
    export

  ccache_cache:
    folder: $CCACHE_DIR

  setup_additional_packages_script: |
    #apt-get update
    #DEBIAN_FRONTEND=noninteractive apt-get -y install ...

  ###
  # Test that code can be built with gcc/clang without warnings
  ###

  setup_script: echo "COPT=-Werror" > src/Makefile.custom

  # Trace probes have a history of getting accidentally broken. Use the
  # different compilers to build with different combinations of dtrace on/off
  # and cassert on/off.

  # gcc, cassert off, dtrace on
  always:
    gcc_warning_script: |
      time ./configure \
        --cache gcc.cache \
        --enable-dtrace \
        ${LINUX_CONFIGURE_FEATURES} \
        CC="ccache gcc" CXX="ccache g++" CLANG="ccache clang"
      make -s -j${BUILD_JOBS} clean
      time make -s -j${BUILD_JOBS} world-bin

  # gcc, cassert on, dtrace off
  always:
    gcc_a_warning_script: |
      time ./configure \
        --cache gcc.cache \
        --enable-cassert \
        ${LINUX_CONFIGURE_FEATURES} \
        CC="ccache gcc" CXX="ccache g++" CLANG="ccache clang"
      make -s -j${BUILD_JOBS} clean
      time make -s -j${BUILD_JOBS} world-bin

  # clang, cassert off, dtrace off
  always:
    clang_warning_script: |
      time ./configure \
        --cache clang.cache \
        ${LINUX_CONFIGURE_FEATURES} \
        CC="ccache clang" CXX="ccache clang++" CLANG="ccache clang"
      make -s -j${BUILD_JOBS} clean
      time make -s -j${BUILD_JOBS} world-bin

  # clang, cassert on, dtrace on
  always:
    clang_a_warning_script: |
      time ./configure \
        --cache clang.cache \
        --enable-cassert \
        --enable-dtrace \
        ${LINUX_CONFIGURE_FEATURES} \
        CC="ccache clang" CXX="ccache clang++" CLANG="ccache clang"
      make -s -j${BUILD_JOBS} clean
      time make -s -j${BUILD_JOBS} world-bin

  # cross-compile to windows
  always:
    mingw_cross_warning_script: |
      time ./configure \
        --host=x86_64-w64-mingw32ucrt \
        --enable-cassert \
        --without-icu \
        CC="ccache x86_64-w64-mingw32ucrt-gcc" \
        CXX="ccache x86_64-w64-mingw32ucrt-g++"
      make -s -j${BUILD_JOBS} clean
      time make -s -j${BUILD_JOBS} world-bin

  ###
  # Verify docs can be built
  ###
  # XXX: Only do this if there have been changes in doc/ since last build
  always:
    docs_build_script: |
      time ./configure \
        --cache gcc.cache \
        CC="ccache gcc" CXX="ccache g++" CLANG="ccache clang"
      make -s -j${BUILD_JOBS} clean
      time make -s -j${BUILD_JOBS} -C doc

  ###
  # Verify headerscheck / cpluspluscheck succeed
  #
  # - Use -fmax-errors, as particularly cpluspluscheck can be very verbose
  ###
  always:
    headers_headerscheck_script: |
      time ./configure \
        ${LINUX_CONFIGURE_FEATURES} \
        --cache gcc.cache \
        --quiet \
        CC="ccache gcc" CXX="ccache g++" CLANG="ccache clang"
      make -s -j${BUILD_JOBS} clean
      time make -s headerscheck EXTRAFLAGS='-fmax-errors=10'
    headers_cpluspluscheck_script: |
      time make -s cpluspluscheck EXTRAFLAGS='-fmax-errors=10'

  always:
    upload_caches: ccache