#!/bin/bash
#
# An absolute BASH_SHELL is taken verbatim by AC_PATH_PROGS and a relative one is dropped
# for the search result, so configure has to check what it ends up with: BASH_SHELL=/bin/sh
# otherwise puts #895 back and only shows up at "make check" or "make deb" (#908).

set -euo pipefail

# shellcheck source=tests/testlib.sh
. "$(dirname "$0")/testlib.sh"
# shellcheck source=tests/proclib.sh
. "$(dirname "$0")/proclib.sh"

sh=${BASH_SHELL:-}
test -n "$sh" || {
    echo "BASH_SHELL is empty; tests/Makefile.am must export the configured value" >&2
    exit 1
}

configure="${abs_top_srcdir:-}/configure"
test -r "$configure" || {
    echo "no configure script at $configure; tests/Makefile.am must export abs_top_srcdir" >&2
    exit 1
}

tmp=$(mktemp -d)
cleanup() {
    # O_RDWR never blocks, and it releases whatever is left stuck opening the FIFO for read.
    exec 9<>"$tmp/fifo" && exec 9>&-
    rm -rf "$tmp"
}
cleanup_push cleanup

# Symlink farm, not the real srcdir: an in-tree config.status makes autoconf refuse it.
mkdir "$tmp/src"
for f in "$abs_top_srcdir"/*; do
    case "${f##*/}" in
    config.status | config.log | config.h | stamp-h1 | Makefile) continue ;;
    esac
    ln -s "$f" "$tmp/src/"
done

mkdir "$tmp/notexec" "$tmp/with space" "$tmp/fakebin"
: >"$tmp/notexec/bash"
chmod 644 "$tmp/notexec/bash"
ln -s "$sh" "$tmp/mybash"
ln -s "$sh" "$tmp/with space/bash"
ln -s "$sh" "$tmp/sh" # bash invoked as "sh" enters POSIX mode
# A "bash" the PATH search will find first, and that answers -c like any other shell.
printf '#!/bin/sh\nexec /bin/sh "$@"\n' >"$tmp/fakebin/bash"
chmod 755 "$tmp/fakebin/bash"
# Executable to "test -x", but bash blocks in open() on one it failed to exec.
mkfifo "$tmp/fifo"
chmod 755 "$tmp/fifo"

# Sampled rather than polled per second: the size read is a fork, and an emulated
# host pays for it. SILENCE clears the slowest single configure probe there.
SAMPLE=5
SILENCE=${HTTRACK_CONFIGURE_SILENCE:-120}
RESERVE=15 # what killing the run and skipping still needs of the budget

n=0
cases=16 # reject/accept calls below; pinned again once they have all run
status=0
log=
rundir=
took=0
# What run() launches, so the checks below can hand it a child that hangs or one that
# only crawls; nothing else may override it.
configure_cmd=(bash "$tmp/src/configure" --disable-https)
run() { # run <label> <env argument>...
    local label=$1 began=$SECONDS
    shift
    n=$((n + 1))
    rundir="$tmp/run$n"
    mkdir "$rundir"
    status=0
    # Capped: configure executes the candidate, and a hang wedges "make check" with no output
    # at all. Polled, not a backgrounded "sleep" watchdog, which outlives the run it guards.
    local had_m=
    case "$-" in *m*) had_m=1 ;; esac
    # Own process group, so the kills below reach what configure spawned: bash 3.2 keeps
    # the subshell it runs in, and killing that alone leaves the child running (macOS).
    set -m
    (cd "$rundir" && env "$@" "${configure_cmd[@]}") \
        >"$rundir/log" 2>&1 &
    local pid=$! waited=0 quiet=0 size=0 now left
    test -n "$had_m" || set +m
    # A hang is silence, not slowness: configure writes a line per probe,
    # but hppa's emulated run can take longer overall than a runner's whole budget (#1146).
    while kill -0 "$pid" 2>/dev/null; do
        sleep 1
        waited=$((waited + 1))
        test "$((waited % SAMPLE))" -eq 0 || continue
        now=$(wc -c <"$rundir/log")
        if test "$now" -gt "$size"; then
            size=$now
            quiet=0
        else
            quiet=$((quiet + SAMPLE))
        fi
        test "$quiet" -lt "$SILENCE" || {
            kill_tree "$pid"
            echo "configure wrote nothing for ${quiet}s of ${waited}s for $label" >&2
            tail -5 "$rundir/log" >&2
            exit 1
        }
        # Still writing but out of time: skip, where the harness would kill the whole test
        # and take the build down with it. Only while writing, and only with a full silence
        # window still affordable, or a hang would reach this before the check above fires
        # and a wedge would report a skip. 0 is the guard off.
        left=$(budget_left)
        if test "$quiet" -eq 0 && test "$left" -ne 0 &&
            test "$left" -le "$((RESERVE + SILENCE))"; then
            kill_tree "$pid"
            echo "$label was still configuring ${waited}s in and the budget is out; skipping" >&2
            exit 77
        fi
    done
    wait "$pid" || status=$?
    log=$(cat "$rundir/log")
    took=$((SECONDS - began))
    echo "run $n ($label): exit $status"
}

# Pace here rather than in run(), which returns with the answer still unjudged: a
# skip between the two would bury a configure that answered wrongly.
paced() {
    skip_if_out_of_budget "$((cases - n))" "$took"
}

reject() { # reject <label> <expected message> <env argument>...
    local label=$1 want=$2
    shift 2
    run "$label" "$@"
    test "$status" -ne 0 || {
        echo "configure accepted $label" >&2
        exit 1
    }
    grep -q "$want" <<<"$log" || {
        echo "$label rejected without '$want':" >&2
        tail -5 <<<"$log" >&2
        exit 1
    }
    paced
}

# accept <label> <expected $(BASH_SHELL), "" for any> <expected message, "" for none> <env argument>...
accept() {
    local label=$1 path=$2 want=$3
    shift 3
    run "$label" "$@"
    test "$status" -eq 0 || {
        echo "configure rejected $label (exit $status):" >&2
        tail -10 <<<"$log" >&2
        exit 1
    }
    got=$(sed -n 's/^BASH_SHELL = //p' "$rundir/Makefile")
    test -n "$got" || {
        echo "$label configured, but the Makefile carries no BASH_SHELL" >&2
        exit 1
    }
    if test -n "$path" && test "$got" != "$path"; then
        echo "$label reached the Makefile as $got" >&2
        exit 1
    fi
    if test -n "$want"; then
        grep -q "$want" <<<"$log" || {
            echo "$label configured without '$want':" >&2
            tail -5 <<<"$log" >&2
            exit 1
        }
    fi
    paced
}

# --- what run() does to a child that hangs, and to one that is merely slow -------
# Driven through configure_cmd, since the real configure can do neither on demand.
probe() { # probe <run number> <seconds of budget left> <command>...
    local want_n=$1 left=$2 rc=0
    shift 2
    (
        # shellcheck disable=SC2030 # the isolation is the point: the real count is next door
        n=$want_n SAMPLE=1 SILENCE=2
        # shellcheck disable=SC2030,SC2031 # likewise: the budget here is the probe's own
        export HTTRACK_TEST_TIMEOUT=$((SECONDS + left))
        configure_cmd=("$@")
        run probe
    ) >"$tmp/probe.log" 2>&1 || rc=$?
    echo "$rc"
}
# A wedge must fail even with the budget gone, or #922 comes back as a skip.
rc=$(probe 90 6 sleep 999)
test "$rc" -eq 1 || fail "a silent configure with 6s of budget reported $rc, want 1"
grep -q 'wrote nothing' "$tmp/probe.log" || fail "the hang was not named: $(cat "$tmp/probe.log")"
# Slow but talking is the emulated buildd, and a skip there beats the harness kill.
rc=$(probe 91 6 bash -c 'while :; do echo tick; sleep 1; done')
test "$rc" -eq 77 || fail "a slow but writing configure with 6s of budget reported $rc, want 77"
# The kill has to reach what configure spawned. bash 3.2 keeps the subshell around the
# child, so killing that alone leaves a live configure behind: it outlives "make check"
# and holds the CI step open to its own timeout, with the suite reporting no failure.
rc=$(probe 92 6 bash -c 'sleep 987 & wait')
test "$rc" -eq 1 || fail "a silent configure with a child of its own reported $rc, want 1"
sleep 1
! ps_snapshot | grep -q '[s]leep 987' || fail "the killed run left its child running"
# The pacer must not fire before the case is judged: run() returns with the verdict
# still unread, and a skip there would bury a configure that answered wrongly. Through
# the real run(), since a stub cannot see a pacer left inside the one it replaced.
verdict() { # verdict <accept|reject> <run number> <status the child exits with>
    local rc=0
    (
        # shellcheck disable=SC2030,SC2031 # the isolation is the point: the real run is next door
        # Cases still to come, or the pacer this is looking for would decline to fire.
        n=$2 cases=$(($2 + 5)) SAMPLE=1
        # Spent by the time the run ends, so a pacer anywhere after it would fire.
        # shellcheck disable=SC2030,SC2031 # likewise: the budget here is the probe's own
        export HTTRACK_TEST_TIMEOUT=$((SECONDS + 4))
        configure_cmd=(bash -c "sleep 3; exit $3")
        # Their arities differ, and an extra argument would reach run() as an env
        # assignment: the child would then fail to exec and answer the wrong question.
        case "$1" in
        accept) accept probe-verdict '' '' ;;
        *) reject probe-verdict '' ;;
        esac
    ) >/dev/null 2>&1 || rc=$?
    test "$rc" -eq 1 || fail "$1 of a wrong answer with the budget spent reported $rc, want 1"
}
verdict accept 80 1 # configure rejected what it must accept
verdict reject 81 0 # configure accepted what it must reject
# The probes ran in subshells, so the real cases below start from a clean count.
cases=16
n=0
status=0
log=
took=0

# The four that configure to completion run first. A reject stops at the
# BASH_SHELL check and costs a fraction of one, and the pacer projects the step it
# just timed: behind the cheap ones it read far too low and 151 met the harness
# kill instead (#1146). Positive control first, as in 196.
accept override "$tmp/mybash" '' "BASH_SHELL=$tmp/mybash"
accept empty '' '' BASH_SHELL=
# No override: an unusable bash is a warning, so a box that has none still builds.
accept searched "$tmp/fakebin/bash" 'no usable bash found' -u BASH_SHELL "PATH=$tmp/fakebin:$PATH"
accept searched-posix-env '' 'POSIXLY_CORRECT or SHELLOPTS' -u BASH_SHELL POSIXLY_CORRECT=1

reject relative 'BASH_SHELL must be an absolute path' BASH_SHELL=relbash
notreg='is not an executable regular file'
reject missing "$notreg" "BASH_SHELL=$tmp/missing/bash"
reject non-executable "$notreg" "BASH_SHELL=$tmp/notexec/bash"
# "test -x" passes a FIFO, and configure then hangs forever instead of rejecting it (#922).
reject fifo "$notreg" "BASH_SHELL=$tmp/fifo"
reject sh-mode 'is a bash in POSIX sh-mode' "BASH_SHELL=$tmp/sh"
# The #908 case: dash on Linux, bash in sh-mode on macOS, unusable either way. The spoofed
# BASH_VERSION is what an ordinary shell echoes straight back, so it cannot be the probe.
reject /bin/sh 'BASH_SHELL=/bin/sh is ' BASH_SHELL=/bin/sh BASH_VERSION=9.9

# make splits the value on whitespace, cuts it at a '#' and expands a '$', and no Makefile
# quotes $(BASH_SHELL).
meta='must not contain shell or make metacharacters'
reject space "$meta" "BASH_SHELL=$tmp/with space/bash"
reject semicolon "$meta" 'BASH_SHELL=/opt/a;b/bash'
# shellcheck disable=SC2016 # the '$' has to reach configure unexpanded
reject dollar "$meta" 'BASH_SHELL=/opt/a$b/bash'
reject hash "$meta" 'BASH_SHELL=/opt/a#b/bash'

# An environment in POSIX mode leaves no path that could pass, so the message must blame it
# and not the shell.
reject posix-env 'POSIXLY_CORRECT or SHELLOPTS' "BASH_SHELL=$sh" POSIXLY_CORRECT=1

# Both at once: clearing the variable would still leave a bash invoked as sh, so the second
# probe has to decide which one to blame instead of reading the environment.
reject sh-mode-in-posix-env "BASH_SHELL=$tmp/sh is a bash in POSIX sh-mode" \
    "BASH_SHELL=$tmp/sh" POSIXLY_CORRECT=1
if grep -q 'POSIXLY_CORRECT or SHELLOPTS' <<<"$log"; then
    echo "a bash invoked as sh was blamed on the environment:" >&2
    tail -5 <<<"$log" >&2
    exit 1
fi

assert_steps_ran "$cases" "$n"
echo "configure validated $n BASH_SHELL values"