set -o pipefail

export PYTHONDONTWRITEBYTECODE=1

SCRIPT_NAME=$0

echo "Running CLI ${SCRIPT_NAME} $@"

echo "running free -g"

free -g

function or_die () {

}

PHASE_TIMINGS=()

CURRENT_PHASE_LABEL=""

CURRENT_PHASE_START=""

tempdir=""

function now_epoch () {

date +%s

}

function format_duration () {

}

function phase_start () {

}

function phase_finish () {

}

function print_phase_summary () {

}

function usage () {

}

or_die cd $(dirname $0)/..

args=$(or_die getopt -a -o h --long build-exe-only,cmake-build-type:,code-coverage,data-basename:,geos-enable-bounds-check:,enable-hypre:,enable-hypre-device:,enable-trilinos:,exchange-dir:,host-config:,install-dir-basename:,makefile,ninja,no-install-schema,no-run-unit-tests,nproc:,repository:,run-integrated-tests,sccache-config:,test-code-style,test-documentation,use-sccache,help -- "$@")

BUILD_EXE_ONLY=false

BUILD_GENERATOR=""

GEOS_INSTALL_SCHEMA=true

HOST_CONFIG="host-configs/environment.cmake"

ENABLE_HYPRE=ON

ENABLE_HYPRE_DEVICE=CPU

GEOS_LA_INTERFACE=Hypre

RUN_UNIT_TESTS=true

RUN_INTEGRATED_TESTS=false

UPLOAD_TEST_BASELINES=false

TEST_CODE_STYLE=false

TEST_DOCUMENTATION=false

ENABLE_TRILINOS=OFF

CODE_COVERAGE=false

NPROC="$(nproc)"

GEOS_ENABLE_BOUNDS_CHECK=ON

SCCACHE_BIN=""

USE_SCCACHE=false

eval set -- ${args}

while :

case $1 in

--build-exe-only)

BUILD_EXE_ONLY=true

RUN_UNIT_TESTS=false

shift;;

--cmake-build-type) CMAKE_BUILD_TYPE=$2; shift 2;;

--ninja)

BUILD_GENERATOR=$1;

shift;;

--data-basename)

DATA_BASENAME=$2

DATA_BASENAME_WE=${DATA_BASENAME%%.*}

DATA_BASENAME_EXT=${DATA_BASENAME#*.}

if [[ ${DATA_BASENAME_EXT} != "tar.gz" ]] ; then

echo "The script ${SCRIPT_NAME} can only pack data into a '.tar.gz' file."

exit 1

fi

unset DATA_BASENAME DATA_BASENAME_EXT

shift 2;;

--geos-enable-bounds-check) GEOS_ENABLE_BOUNDS_CHECK=$2; shift 2;;

--enable-hypre) ENABLE_HYPRE=$2; shift 2;;

--enable-hypre-device) ENABLE_HYPRE_DEVICE=$2; shift 2;;

--enable-trilinos) ENABLE_TRILINOS=$2; shift 2;;

--exchange-dir) DATA_EXCHANGE_DIR=$2; shift 2;;

--host-config) HOST_CONFIG=$2; shift 2;;

--install-dir-basename) GEOS_DIR=${GEOSX_TPL_DIR}/../$2; shift 2;;

--makefile) BUILD_GENERATOR=""; shift;;

--no-install-schema) GEOS_INSTALL_SCHEMA=false; shift;;

--no-run-unit-tests) RUN_UNIT_TESTS=false; shift;;

--nproc) NPROC=$2; shift 2;;

--repository) GEOS_SRC_DIR=$2; shift 2;;

--run-integrated-tests) RUN_INTEGRATED_TESTS=true; shift;;

--upload-test-baselines) UPLOAD_TEST_BASELINES=true; shift;;

--code-coverage) CODE_COVERAGE=true; shift;;

--sccache-config) SCCACHE_CONFIG_FILE=$2; shift 2;;

--use-sccache) USE_SCCACHE=true; shift;;

--test-code-style) TEST_CODE_STYLE=true; shift;;

--test-documentation) TEST_DOCUMENTATION=true; shift;;

-h | --help) usage; shift;;

# -- means the end of the arguments; drop this, and break out of the while loop

--) shift; break;;

*) >&2 echo Unsupported option: $1

usage;;

esac

if [[ -z "${GEOS_SRC_DIR}" ]]; then

echo "Variable GEOS_SRC_DIR is either empty or not defined. Please define it using '--repository'."

exit 1

cleanup() {

}

trap cleanup EXIT

if [[ -z "${GEOS_DIR}" ]]; then

echo "Installation folder undefined. Set to default value '/dev/null'. You can define it using '--install-dir-basename'."

GEOS_DIR=/dev/null

if [[ "${ENABLE_HYPRE}" = ON ]]; then

GEOS_LA_INTERFACE=Hypre

GEOS_LA_INTERFACE=Trilinos

if [[ "${USE_SCCACHE}" == true ]]; then

SCCACHE_BIN=${SCCACHE:-$(command -v sccache || true)}

if [[ -z "${SCCACHE_BIN}" ]]; then

echo "sccache was requested, but no sccache binary is available in the container."

exit 1

fi

if [[ -n "${SCCACHE_CONFIG_FILE:-}" ]]; then

if [[ ! -f "${GEOS_SRC_DIR}/${SCCACHE_CONFIG_FILE}" ]]; then

echo "Unable to find requested sccache config file at ${GEOS_SRC_DIR}/${SCCACHE_CONFIG_FILE}."

exit 1

fi

or_die mkdir -p ${HOME}/.config/sccache

or_die cp "${GEOS_SRC_DIR}/${SCCACHE_CONFIG_FILE}" "${HOME}/.config/sccache/config"

fi

# Backend-specific credentials and endpoints are injected through the environment and/or config file.

SCCACHE_CMAKE_ARGS="-DCMAKE_C_COMPILER_LAUNCHER=${SCCACHE_BIN} -DCMAKE_CXX_COMPILER_LAUNCHER=${SCCACHE_BIN} -DCMAKE_CUDA_COMPILER_LAUNCHER=${SCCACHE_BIN}"

if [[ -f /certs/ca-bundle.crt ]]; then

export SSL_CERT_FILE=/certs/ca-bundle.crt

export CURL_CA_BUNDLE=/certs/ca-bundle.crt

export REQUESTS_CA_BUNDLE=/certs/ca-bundle.crt

fi

echo "sccache initial state"

${SCCACHE_BIN} --show-stats || true

if [ -z "${NPROC}" ]; then

NPROC=$(nproc)

echo "NPROC unset, setting to ${NPROC}..."

echo "Using ${NPROC} cores."

if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then

phase_start "Set up integrated test environment"

echo "Running the integrated tests has been requested."

# We install the python environment required by ATS to run the integrated tests.

#or_die apt-get update

or_die apt-get install -y virtualenv python3-dev python-is-python3

ATS_PYTHON_HOME=/tmp/run_integrated_tests_virtualenv

or_die virtualenv ${ATS_PYTHON_HOME}

python3 -m pip cache purge

# Setup a temporary directory to hold tests

tempdir=$(mktemp -d)

echo "Setting up a temporary directory to hold tests and baselines: $tempdir"

ATS_BASELINE_DIR=$tempdir/GEOS_integratedTests_baselines

ATS_WORKING_DIR=$tempdir/GEOS_integratedTests_working

export ATS_FILTER="np<=32"

ATS_CMAKE_ARGS="-DATS_ARGUMENTS=\"--machine openmpi --ats openmpi_mpirun=/usr/bin/mpirun --ats openmpi_args=--allow-run-as-root --ats openmpi_procspernode=32 --ats openmpi_maxprocs=32\" -DPython3_ROOT_DIR=${ATS_PYTHON_HOME} -DPython3_EXECUTABLE=${ATS_PYTHON_HOME}/bin/python3 -DATS_BASELINE_DIR=${ATS_BASELINE_DIR} -DATS_WORKING_DIR=${ATS_WORKING_DIR}"

phase_finish 0

if [[ "${CODE_COVERAGE}" = true ]]; then

or_die apt-get update

or_die apt-get install -y lcov

GEOS_BUILD_DIR=/tmp/geos-build

phase_start "Configure"

or_die python3 scripts/config-build.py \

-hc ${HOST_CONFIG} \

-bt ${CMAKE_BUILD_TYPE} \

-bp ${GEOS_BUILD_DIR} \

-ip ${GEOS_DIR} \

${BUILD_GENERATOR} \

-DBLT_MPI_COMMAND_APPEND='"--allow-run-as-root;--oversubscribe"' \

-DGEOS_INSTALL_SCHEMA=${GEOS_INSTALL_SCHEMA} \

-DENABLE_HYPRE=${ENABLE_HYPRE} \

-DENABLE_HYPRE_DEVICE=${ENABLE_HYPRE_DEVICE} \

-DENABLE_TRILINOS=${ENABLE_TRILINOS} \

-DGEOS_LA_INTERFACE:PATH=${GEOS_LA_INTERFACE} \

-DENABLE_COVERAGE=$([[ "${CODE_COVERAGE}" = true ]] && echo 1 || echo 0) \

-DGEOS_ENABLE_BOUNDS_CHECK=${GEOS_ENABLE_BOUNDS_CHECK} \

${SCCACHE_CMAKE_ARGS} \

${ATS_CMAKE_ARGS}

phase_finish 0

or_die cd ${GEOS_BUILD_DIR}

if [[ "${TEST_CODE_STYLE}" = true ]]; then

phase_start "Code style check"

or_die ctest --output-on-failure -R "testUncrustifyCheck"

phase_finish 0

exit 0

if [[ "${TEST_DOCUMENTATION}" = true ]]; then

phase_start "Documentation check"

or_die ctest --output-on-failure -R "testDoxygenCheck"

phase_finish 0

exit 0

phase_start "Build"

if [[ "${BUILD_EXE_ONLY}" = true ]]; then

or_die cmake --build . -j $NPROC --target geosx

or_die cmake --build . -j $NPROC

#or_die cmake --install .

if [[ ! -z "${DATA_BASENAME_WE}" ]]; then

# Here we pack the installation.

# The `--transform` parameter provides consistency between the tarball name and the unpacked folder.

echo "DATA_EXCHANGE_DIR=${DATA_EXCHANGE_DIR}"

echo "DATA_BASENAME_WE=${DATA_BASENAME_WE}"

echo "GEOS_TPL_DIR=${GEOS_TPL_DIR}"

echo "GEOSX_TPL_DIR=${GEOSX_TPL_DIR}"

GEOS_TPL_DIR=${GEOSX_TPL_DIR}

echo tar czf ${DATA_EXCHANGE_DIR}/${DATA_BASENAME_WE}.tar.gz --directory=${GEOS_TPL_DIR}/.. --transform "s|^./|${DATA_BASENAME_WE}/|" .

or_die tar czf ${DATA_EXCHANGE_DIR}/${DATA_BASENAME_WE}.tar.gz --directory=${GEOS_TPL_DIR}/.. --transform "s|^./|${DATA_BASENAME_WE}/|" .

fi

phase_finish 0

if [[ -n "${SCCACHE_BIN}" ]]; then

echo "sccache post-build state"

or_die ${SCCACHE_BIN} --show-adv-stats

if [[ "${CODE_COVERAGE}" = true ]]; then

phase_start "Generate code coverage"

export OMP_NUM_THREADS=1

or_die cmake --build . --target coreComponents_coverage

or_die cp -r ${GEOS_BUILD_DIR}/coreComponents_coverage.info.cleaned ${GEOS_SRC_DIR}/geos_coverage.info.cleaned

phase_finish 0

if [[ "${RUN_UNIT_TESTS}" = true ]]; then

phase_start "Unit tests"

if [ ${HOSTNAME} == 'streak.llnl.gov' ] || [ ${HOSTNAME} == 'streak2.llnl.gov' ]; then

or_die ctest --output-on-failure -E "testUncrustifyCheck|testDoxygenCheck|testExternalSolvers"

else

or_die ctest --output-on-failure -E "testUncrustifyCheck|testDoxygenCheck"

fi

phase_finish 0

if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then

# fix the setuptools/distutils conflict

export SETUPTOOLS_USE_DISTUTILS=stdlib

# We split the process in two steps. First installing the environment, then running the tests.

phase_start "Build ATS environment"

or_die cmake --build . --target ats_environment

phase_finish 0

# The tests are not run using cmake (`cmake --build . --verbose --target ats_run`)

# because with ninja it swallows the output while all the

# simulations are running.

# We directly use the script instead...

echo "Available baselines:"

ls -lR /tmp/geos/baselines

echo "Running integrated tests..."

phase_start "Integrated tests"

integratedTests/geos_ats.sh --baselineCacheDirectory /tmp/geos/baselines

ATS_RUN_STATUS=$?

phase_finish "${ATS_RUN_STATUS}"

phase_start "Process integrated test logs"

PROCESS_LOGS_STATUS=0

echo "Processing logs..."

bin/geos_ats_process_tests_fails --directory integratedTests/TestResults &> integratedTests/TestResults/processedTestsLogs.txt || PROCESS_LOGS_STATUS=$?

if [[ "${PROCESS_LOGS_STATUS}" -eq 0 ]]; then

echo "Packing logs..."

tar -czf ${DATA_EXCHANGE_DIR}/test_logs_${DATA_BASENAME_WE}.tar.gz integratedTests/TestResults || PROCESS_LOGS_STATUS=$?

fi

phase_finish "${PROCESS_LOGS_STATUS}"

echo "Checking results..."

phase_start "Check integrated test results"

bin/geos_ats_log_check integratedTests/TestResults/test_results.ini -y ${GEOS_SRC_DIR}/.integrated_tests.yaml &> $tempdir/log_check.txt

LOG_CHECK_STATUS=$?

cat $tempdir/log_check.txt

phase_finish "${LOG_CHECK_STATUS}"

if grep -q "Overall status: PASSED" "$tempdir/log_check.txt"; then

echo "IntegratedTests passed. No rebaseline required."

INTEGRATED_TEST_EXIT_STATUS=0

else

echo "IntegratedTests failed. Rebaseline is required."

# Rebaseline and pack into an archive

echo "Rebaselining..."

phase_start "Rebaseline integrated tests"

REBASELINE_STATUS=0

integratedTests/geos_ats.sh -a rebaselinefailed || REBASELINE_STATUS=$?

if [[ "${REBASELINE_STATUS}" -eq 0 ]]; then

echo "Packing baselines..."

integratedTests/geos_ats.sh -a pack_baselines --baselineArchiveName ${DATA_EXCHANGE_DIR}/baseline_${DATA_BASENAME_WE}.tar.gz --baselineCacheDirectory /tmp/geos/baselines || REBASELINE_STATUS=$?

fi

phase_finish "${REBASELINE_STATUS}"

INTEGRATED_TEST_EXIT_STATUS=1

fi

echo "Done!"

# INTEGRATED_TEST_EXIT_STATUS=$?

echo "The return code of the integrated tests is ${INTEGRATED_TEST_EXIT_STATUS}"

phase_start "Clean build directory"

or_die cmake --build . --target clean

phase_finish 0

phase_start "Clean repository"

or_die cd ${GEOS_SRC_DIR}/inputFiles

find . -name '*.pyc' -delete

phase_finish 0

if [[ ! -z "${INTEGRATED_TEST_EXIT_STATUS+x}" ]]; then

echo "Exiting the build process with exit status ${INTEGRATED_TEST_EXIT_STATUS} from the integrated tests."

exit ${INTEGRATED_TEST_EXIT_STATUS}

echo "Exiting the build process with exit status 0."

exit 0