472 lines
12 KiB
Bash
Executable File
472 lines
12 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
set -u
|
|
|
|
SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
|
|
ROOT_DIR="$(cd -- "${SCRIPT_DIR}/.." && pwd)"
|
|
VENV_DIR="${FFX_TEST_VENV_DIR:-${ROOT_DIR}/.venv}"
|
|
VENV_BIN_DIR="${VENV_DIR}/bin"
|
|
VENV_PYTHON="${VENV_BIN_DIR}/python"
|
|
VENV_PIP="${VENV_BIN_DIR}/pip"
|
|
|
|
CHECK_ONLY=0
|
|
READINESS_FAILURES=0
|
|
INSTALL_FAILURES=0
|
|
|
|
MISSING_REQUIRED_SYSTEM=()
|
|
|
|
COLOR_RESET=""
|
|
COLOR_GREEN=""
|
|
COLOR_YELLOW=""
|
|
COLOR_RED=""
|
|
|
|
if [ -t 1 ]; then
|
|
COLOR_RESET="$(printf '\033[0m')"
|
|
COLOR_GREEN="$(printf '\033[32m')"
|
|
COLOR_YELLOW="$(printf '\033[33m')"
|
|
COLOR_RED="$(printf '\033[31m')"
|
|
fi
|
|
|
|
usage() {
|
|
cat <<EOF
|
|
Usage: $(basename "$0") [--check] [--help]
|
|
|
|
Prepare the repo-local FFX test environment at:
|
|
${VENV_DIR}
|
|
|
|
Actions:
|
|
- verify or install required system commands for tests
|
|
- create or reuse the repo-local test virtualenv
|
|
- install this repository into the venv with Python test and docs extras
|
|
|
|
Options:
|
|
--check Report readiness only. Do not create, install, or modify.
|
|
--help Show this help text.
|
|
|
|
Environment overrides:
|
|
FFX_TEST_VENV_DIR Override the test virtualenv path. Defaults to ${ROOT_DIR}/.venv.
|
|
|
|
Notes:
|
|
- This script prepares a project-local test environment, not the persistent user bundle.
|
|
- The persistent bundle setup remains owned by tools/setup.sh.
|
|
EOF
|
|
}
|
|
|
|
status_ok() {
|
|
printf '%sok%s' "${COLOR_GREEN}" "${COLOR_RESET}"
|
|
}
|
|
|
|
status_warn() {
|
|
printf '%swarn%s' "${COLOR_YELLOW}" "${COLOR_RESET}"
|
|
}
|
|
|
|
status_fail() {
|
|
printf '%sfailed%s' "${COLOR_RED}" "${COLOR_RESET}"
|
|
}
|
|
|
|
report_component() {
|
|
local level="$1"
|
|
local label="$2"
|
|
local detail="$3"
|
|
local rendered_status=""
|
|
|
|
case "${level}" in
|
|
ok)
|
|
rendered_status="$(status_ok)"
|
|
;;
|
|
warn)
|
|
rendered_status="$(status_warn)"
|
|
;;
|
|
*)
|
|
rendered_status="$(status_fail)"
|
|
;;
|
|
esac
|
|
|
|
printf '[%s] %s%s\n' "${rendered_status}" "${label}" "${detail:+: $detail}"
|
|
}
|
|
|
|
command_exists() {
|
|
command -v "$1" >/dev/null 2>&1
|
|
}
|
|
|
|
check_python_venv_support() {
|
|
python3 -m venv --help >/dev/null 2>&1
|
|
}
|
|
|
|
check_system_command() {
|
|
command_exists "$1"
|
|
}
|
|
|
|
check_venv_python() {
|
|
[ -x "${VENV_PYTHON}" ]
|
|
}
|
|
|
|
check_venv_pip() {
|
|
check_venv_python && "${VENV_PIP}" --version >/dev/null 2>&1
|
|
}
|
|
|
|
check_venv_ffx() {
|
|
check_venv_python && "${VENV_PYTHON}" -m ffx version >/dev/null 2>&1
|
|
}
|
|
|
|
check_venv_pytest() {
|
|
check_venv_python && "${VENV_PYTHON}" -m pytest --version >/dev/null 2>&1
|
|
}
|
|
|
|
check_venv_sphinx() {
|
|
check_venv_python && "${VENV_BIN_DIR}/sphinx-build" --version >/dev/null 2>&1
|
|
}
|
|
|
|
check_venv_docs_packages() {
|
|
check_venv_python && "${VENV_PYTHON}" - <<'PY' >/dev/null 2>&1
|
|
import esbonio
|
|
import sphinx
|
|
import sphinx_rtd_theme
|
|
PY
|
|
}
|
|
|
|
check_editable_install() {
|
|
check_venv_python && FFX_REPO_ROOT="${ROOT_DIR}" "${VENV_PYTHON}" - <<'PY' >/dev/null 2>&1
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
from pathlib import Path
|
|
import ffx
|
|
|
|
repo_root = Path(os.environ["FFX_REPO_ROOT"]).resolve()
|
|
package_path = Path(ffx.__file__).resolve()
|
|
|
|
raise SystemExit(0 if repo_root in package_path.parents else 1)
|
|
PY
|
|
}
|
|
|
|
check_python_environment_ready() {
|
|
check_venv_python &&
|
|
check_venv_pip &&
|
|
check_venv_pytest &&
|
|
check_venv_sphinx &&
|
|
check_venv_docs_packages &&
|
|
check_venv_ffx &&
|
|
check_editable_install
|
|
}
|
|
|
|
command_detail() {
|
|
command -v "$1" || printf "command '%s' not found" "$1"
|
|
}
|
|
|
|
python_venv_detail() {
|
|
if check_python_venv_support; then
|
|
printf 'python3 -m venv is available'
|
|
else
|
|
printf 'python3 venv support is unavailable'
|
|
fi
|
|
}
|
|
|
|
venv_python_detail() {
|
|
if check_venv_python; then
|
|
printf '%s' "${VENV_PYTHON}"
|
|
else
|
|
printf 'missing %s' "${VENV_PYTHON}"
|
|
fi
|
|
}
|
|
|
|
venv_pip_detail() {
|
|
if check_venv_pip; then
|
|
"${VENV_PIP}" --version
|
|
else
|
|
printf 'missing pip in %s' "${VENV_DIR}"
|
|
fi
|
|
}
|
|
|
|
venv_ffx_detail() {
|
|
if check_venv_ffx; then
|
|
printf 'ffx import and CLI entry are available'
|
|
else
|
|
printf 'ffx is not installed in %s' "${VENV_DIR}"
|
|
fi
|
|
}
|
|
|
|
venv_pytest_detail() {
|
|
if check_venv_pytest; then
|
|
"${VENV_PYTHON}" -m pytest --version 2>/dev/null | head -n 1
|
|
else
|
|
printf 'pytest is not installed in %s' "${VENV_DIR}"
|
|
fi
|
|
}
|
|
|
|
venv_sphinx_detail() {
|
|
if check_venv_sphinx; then
|
|
"${VENV_BIN_DIR}/sphinx-build" --version 2>&1
|
|
else
|
|
printf 'sphinx-build is not installed in %s' "${VENV_DIR}"
|
|
fi
|
|
}
|
|
|
|
venv_docs_packages_detail() {
|
|
if check_venv_docs_packages; then
|
|
printf 'Sphinx, Read the Docs theme, and Esbonio packages are importable'
|
|
else
|
|
printf 'one or more docs packages are missing in %s' "${VENV_DIR}"
|
|
fi
|
|
}
|
|
|
|
editable_install_detail() {
|
|
if check_editable_install; then
|
|
printf 'ffx resolves from %s' "${ROOT_DIR}"
|
|
else
|
|
printf 'ffx does not resolve from the project source tree'
|
|
fi
|
|
}
|
|
|
|
report_required_command() {
|
|
local label="$1"
|
|
local command_name="$2"
|
|
|
|
if check_system_command "${command_name}"; then
|
|
report_component ok "${label}" "$(command_detail "${command_name}")"
|
|
else
|
|
report_component failed "${label}" "$(command_detail "${command_name}")"
|
|
MISSING_REQUIRED_SYSTEM+=("${command_name}")
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
}
|
|
|
|
print_system_status() {
|
|
MISSING_REQUIRED_SYSTEM=()
|
|
|
|
echo "System toolchain status:"
|
|
report_required_command "git" "git"
|
|
report_required_command "python3" "python3"
|
|
|
|
if check_system_command "python3" && check_python_venv_support; then
|
|
report_component ok "python3 venv" "$(python_venv_detail)"
|
|
else
|
|
report_component failed "python3 venv" "$(python_venv_detail)"
|
|
MISSING_REQUIRED_SYSTEM+=("python3-venv")
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
|
|
report_required_command "ffmpeg" "ffmpeg"
|
|
report_required_command "ffprobe" "ffprobe"
|
|
report_required_command "cpulimit" "cpulimit"
|
|
}
|
|
|
|
print_python_status() {
|
|
echo "Repo test and docs virtualenv status:"
|
|
|
|
if check_venv_python; then
|
|
report_component ok "test virtualenv" "$(venv_python_detail)"
|
|
else
|
|
report_component failed "test virtualenv" "$(venv_python_detail)"
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
|
|
if check_venv_pip; then
|
|
report_component ok "test pip" "$(venv_pip_detail)"
|
|
else
|
|
report_component failed "test pip" "$(venv_pip_detail)"
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
|
|
if check_venv_pytest; then
|
|
report_component ok "test pytest" "$(venv_pytest_detail)"
|
|
else
|
|
report_component failed "test pytest" "$(venv_pytest_detail)"
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
|
|
if check_venv_sphinx; then
|
|
report_component ok "docs sphinx" "$(venv_sphinx_detail)"
|
|
else
|
|
report_component failed "docs sphinx" "$(venv_sphinx_detail)"
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
|
|
if check_venv_docs_packages; then
|
|
report_component ok "docs packages" "$(venv_docs_packages_detail)"
|
|
else
|
|
report_component failed "docs packages" "$(venv_docs_packages_detail)"
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
|
|
if check_venv_ffx; then
|
|
report_component ok "test ffx" "$(venv_ffx_detail)"
|
|
else
|
|
report_component failed "test ffx" "$(venv_ffx_detail)"
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
|
|
if check_editable_install; then
|
|
report_component ok "editable source" "$(editable_install_detail)"
|
|
else
|
|
report_component failed "editable source" "$(editable_install_detail)"
|
|
READINESS_FAILURES=$((READINESS_FAILURES + 1))
|
|
fi
|
|
}
|
|
|
|
print_status_report() {
|
|
READINESS_FAILURES=0
|
|
|
|
print_system_status
|
|
echo
|
|
print_python_status
|
|
}
|
|
|
|
detect_package_manager() {
|
|
if command_exists apt-get; then
|
|
printf 'apt-get\n'
|
|
return 0
|
|
fi
|
|
if command_exists pacman; then
|
|
printf 'pacman\n'
|
|
return 0
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
run_root_command() {
|
|
if [ "${EUID}" -eq 0 ]; then
|
|
"$@"
|
|
elif command_exists sudo; then
|
|
sudo -n "$@"
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
install_system_requirements() {
|
|
local package_manager
|
|
|
|
if [ "${#MISSING_REQUIRED_SYSTEM[@]}" -eq 0 ]; then
|
|
return 0
|
|
fi
|
|
|
|
if ! package_manager="$(detect_package_manager)"; then
|
|
printf 'No supported package manager found for automatic system preparation.\n' >&2
|
|
INSTALL_FAILURES=$((INSTALL_FAILURES + 1))
|
|
return 1
|
|
fi
|
|
|
|
case "${package_manager}" in
|
|
apt-get)
|
|
printf 'Installing required system dependencies via apt-get...\n'
|
|
if ! run_root_command apt-get update; then
|
|
printf 'apt-get update failed or requires interactive sudo.\n' >&2
|
|
INSTALL_FAILURES=$((INSTALL_FAILURES + 1))
|
|
return 1
|
|
fi
|
|
if ! run_root_command apt-get install -y git python3 python3-venv ffmpeg cpulimit; then
|
|
printf 'apt-get install failed or requires interactive sudo.\n' >&2
|
|
INSTALL_FAILURES=$((INSTALL_FAILURES + 1))
|
|
return 1
|
|
fi
|
|
;;
|
|
pacman)
|
|
printf 'Installing required system dependencies via pacman...\n'
|
|
if ! run_root_command pacman -Sy --noconfirm git python ffmpeg cpulimit; then
|
|
printf 'pacman install failed or requires interactive sudo.\n' >&2
|
|
INSTALL_FAILURES=$((INSTALL_FAILURES + 1))
|
|
return 1
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
|
|
ensure_test_venv() {
|
|
if ! check_venv_python; then
|
|
printf 'Creating repo test virtualenv at %s...\n' "${VENV_DIR}"
|
|
if ! python3 -m venv "${VENV_DIR}"; then
|
|
printf 'Failed to create test virtualenv at %s.\n' "${VENV_DIR}" >&2
|
|
INSTALL_FAILURES=$((INSTALL_FAILURES + 1))
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
if ! check_venv_pip; then
|
|
printf 'Missing pip in %s.\n' "${VENV_DIR}" >&2
|
|
INSTALL_FAILURES=$((INSTALL_FAILURES + 1))
|
|
return 1
|
|
fi
|
|
|
|
printf 'Installing FFX package with test and docs extras into %s...\n' "${VENV_DIR}"
|
|
if ! (
|
|
cd "${ROOT_DIR}" &&
|
|
"${VENV_PIP}" install --editable '.[test,docs]'
|
|
); then
|
|
printf 'Failed to install FFX package with test and docs extras into %s.\n' "${VENV_DIR}" >&2
|
|
INSTALL_FAILURES=$((INSTALL_FAILURES + 1))
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
parse_args() {
|
|
while [ "$#" -gt 0 ]; do
|
|
case "$1" in
|
|
--check)
|
|
CHECK_ONLY=1
|
|
;;
|
|
--help|-h)
|
|
usage
|
|
exit 0
|
|
;;
|
|
*)
|
|
printf 'Unknown option: %s\n\n' "$1" >&2
|
|
usage >&2
|
|
exit 2
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
}
|
|
|
|
main() {
|
|
parse_args "$@"
|
|
|
|
print_status_report
|
|
|
|
if [ "${CHECK_ONLY}" -eq 0 ]; then
|
|
if [ "${#MISSING_REQUIRED_SYSTEM[@]}" -gt 0 ]; then
|
|
echo
|
|
install_system_requirements
|
|
fi
|
|
|
|
if check_python_environment_ready; then
|
|
echo
|
|
report_component ok "Python package install" "repo test and docs virtualenv is already ready"
|
|
elif check_system_command "python3" && check_python_venv_support; then
|
|
echo
|
|
ensure_test_venv
|
|
fi
|
|
|
|
echo
|
|
print_status_report
|
|
fi
|
|
|
|
echo
|
|
if [ "${INSTALL_FAILURES}" -gt 0 ]; then
|
|
echo "One or more test preparation steps failed; see the status checks above." >&2
|
|
exit 1
|
|
fi
|
|
|
|
if [ "${READINESS_FAILURES}" -gt 0 ]; then
|
|
if [ "${CHECK_ONLY}" -eq 1 ]; then
|
|
echo "The FFX test and docs environment is incomplete." >&2
|
|
else
|
|
echo "Required test or docs components are still missing after preparation." >&2
|
|
fi
|
|
exit 1
|
|
fi
|
|
|
|
if [ "${CHECK_ONLY}" -eq 1 ]; then
|
|
echo "The FFX test and docs environment is ready."
|
|
else
|
|
echo "The FFX test and docs environment is prepared."
|
|
fi
|
|
}
|
|
|
|
main "$@"
|