setup

#!/usr/bin/env bash
#
# Setup script for https://github.com/markosamuli/linux-machine and
# https://github.com/markosamuli/macos-machine Ansible playbooks.
#
# 2020-09-07:
# - Support for Debian
#
# 2020-09-06:
# - Upgrade outdated Ansible Homebrew formula
# - Detect installed Ansible Homebrew path correctly during install
#
# 2020-09-04:
# - Re-install Xcode Command Line Tools (CLT) after upgrade
# - Wait for Xcode CLT installation to complete in the background
#
# 2020-08-31:
# - Detect WSL1 / WSL2 version and pass it to the Ansible playbook
# - Use 'auto' for detecting Python in Ubuntu 20.04 LTS
# - Added debug() function that logs only if DEBUG environment variable is
#   defined
#
# 2020-08-30:
# - Use Ansible 2.9 as the default version
# - Update APT cache before installing packages
#
# 2020-08-29:
# - Fix issue with the script detecting pyenv when .python-version file exists
#   even if pyenv was not installed on the system
# - Do not install Ansible from PPA on Ubuntu 20.04 LTS
# - Detect Linux distribution release name
#
# 2020-07-01:
# - Use the new Bash Homebrew installer
#
# 2020-02-16:
# - Require minimum Ansible version 2.8 (snap module for Ubuntu)
# - Added '--no-install-ansible' option
# - Added '--update-roles' option
#
# 2019-11-24:
# - Fix Ansible version checking on macOS
#
# 2019-11-22:
# - Rework on the setup script for improved Ansible installation when using
#   pyenv or virtualenv or calling Ansible with any non-system paths
# - Use bash executable instead of sh with Ansible on WSL environments
#
# 2019-11-21:
# - Require minimum Ansible version 2.7
# - Install Ansible 2.8 as the default version
# - Support for installing Ansible in a local virtualenv from PyPI
# - Allow setting the default Ansible version with MACHINE_ANSIBLE_VERSION
#   environment variable
# - Check that we're not using Ansible v2.8.6
# - Support for uninstalling existing Ansible installations
# - Added new long command line options in setup script
#
# 2019-11-20:
# - Check for outdated Homebrew packages on macOS
#
# 2019-11-09:
# - Check the current user is not root

DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)

# Commands
run_playbook=1 # Run playbook as default command
syntax_check=0 # Run command to check syntax
list_tags=0    # Run command to list tags

# Setup options
check_os_upgrades=1   # Check for OS upgrades
install_roles=1       # Install Ansible roles
install_ansible=1     # Install Ansible
install_roles_force=0 # Force overwriting existing Ansible roles
update_roles=0        # Update Ansible roles to the latest versions
print_versions=0      # Print Python and Ansible versions
upgrade_ansible=0     # Upgrade Ansible to the latest version

# System properties
is_macos=""        # macOS
is_linux=""        # Linux
is_ubuntu=""       # Ubuntu
is_debian=""       # Debian
is_pengwin=""      # Pengwin
is_wsl=""          # Windows Subsystem for Linux
distrib_release="" # OS release codename
wsl_version=""     # WSL1 / WSL2

# macOS specific setup options
install_homebrew=1 # Install Homebrew
install_xcode=1    # Install Xcode

# Environment configuration
deploy_env="local"

# Local variables
local_vars_file="machine.yaml"

# Ansible playbook options
ansible_playbook="playbooks/main.yml"
ansible_roles="playbooks/roles"
ansible_tags=""
ansible_skip_tags=""
ansible_verbose=0
ansible_become=0

# Ansible pyenv version / environment name
ansible_pyenv=""

# Ansible virtualenv path
ansible_virtualenv="${DIR}/.venv"

# Ansible version test
required_ansible_version="2.8"

# Ansible version to install
ansible_version="${MACHINE_ANSIBLE_VERSION:-2.9}"

# Ansible PPA to use
ansible_ppa="ansible/ansible-${ansible_version}"
ansible_ppa_key_id="93C4A3FD7BB9C367"

# Ansible installation options
ansible_pypi_enabled="${MACHINE_ANSIBLE_PYPI}"
ansible_apt_enabled="${MACHINE_ANSIBLE_APT}"
ansible_homebrew_enabled="${MACHINE_ANSIBLE_HOMEBREW}"
ansible_virtualenv_enabled="${MACHINE_ANSIBLE_VIRTUALENV}"
ansible_pyenv_enabled="${MACHINE_ANSIBLE_PYENV}"

error() {
    echo "$@" 1>&2
}

debug() {
    if [ -z "${DEBUG}" ]; then
        return 0
    fi
    echo "DEBUG: $*" 1>&2
}

# Print usage help
show_help() {
    echo "Usage: $0"

    cat <<END_OF_OPTIONS

  -h         Show this help
  -f         Force overwriting existing Ansible roles
  -v         Verbose mode
  -n         Do not run Ansible playbook
  -q         Do not install Ansible requirements
  -l         List available Ansible tags
  -s         Ansible playbook syntax check
  -u         Update Ansible roles to the latest versions
  -t TAGS    Run Ansible with the given comma separated list of tags
  -i TAGS    Skip the given list of tags

  --reinstall-ansible
      Remove and re-install Ansible

  --enable-ansible-pypi
      Enable Ansible installation from PyPI into a virtualenv

  --disable-ansible-pypi
      Disable Ansible installation from PyPI into a virtualenv

  --install-ansible
      Enable Ansible installation

  --no-run-playbook
      Disable Ansible playbooks from being run

  --no-install-roles
      Disable Ansible roles from being installed or updated

  --upgrade-ansible
      Upgrade outdated Ansible version (macOS with Homebrew only)

  --verbose
      Enable verbose Ansible output

  --print-versions
      Print Ansible and Python versions
END_OF_OPTIONS
}

# Get Ansible version
get_ansible_version() {
    local version
    version=$(ansible_exec ansible --version 2>/dev/null)
    if [ -n "$version" ]; then
        echo "${version}" | grep "^ansible" | awk '{ print $2 }'
    fi
}

# Check installed Ansible version meets the requirements
check_installed_ansible_version() {
    local required="${required_ansible_version}"
    local installed
    installed="$(get_ansible_version)"
    # Fail if we don't get a version number
    if [ -z "${installed}" ]; then
        error "Ansible not installed"
        exit 1
    fi
    # Print installed Ansible version
    if is_true "${print_versions}"; then
        echo "*** Ansible version ${installed} installed"
    fi
    # Check that the installed major and minor version match the require version
    if ! compare_ansible_version "${required}" "${installed}"; then
        error "Ansible ${required} required"
        exit 1
    fi
    # Check that we're not using Ansible v2.8.6
    if [ "${installed}" == "2.8.6" ]; then
        error "Ansible v2.8.6 is not supported, try upgrading to Ansible v2.8.7"
        return 1
    fi
}

# Check Ansible major and minor version matches the required version
compare_ansible_version() {
    local IFS=.
    # shellcheck disable=SC2206
    local required=($1)
    # shellcheck disable=SC2206
    local installed=($2)
    # shellcheck disable=SC2004
    if ((${installed[0]} < ${required[0]})); then
        return 1
    fi
    # shellcheck disable=SC2004
    if ((${installed[1]} < ${required[1]})); then
        return 1
    fi
    return 0
}

# Install dependencies on Linux
install_linux_dependencies() {
    debug "install Linux dependencies"
    if is_true "${install_ansible}"; then
        install_ansible
    fi
}

# Install dependencies on macOS
install_macos_dependencies() {
    if is_true "${install_xcode}"; then
        install_xcode
    fi
    if is_true "${install_homebrew}"; then
        install_homebrew
    fi
    if is_true "${install_ansible}"; then
        install_ansible
    fi
    if is_true "${upgrade_ansible}"; then
        upgrade_ansible
    fi
}

# Install Xcode Command Line Tools
install_xcode() {
    echo "*** Installing Xcode Command Line Tools..."
    xcode-select --install ||
        {
            error "Failed to install Xcode Command Line Tools"
            exit 1
        }
    echo "Follow instructions on the dialog to complete the installation."
    echo "Press [CTRL+C] to stop."
    printf "Waiting for install to complete"
    while is_true "${install_xcode}"; do
        printf "."
        sleep 5
        configure_xcode
    done
}

# Install Homebrew
install_homebrew() {
    if command -v brew >/dev/null; then
        return 0
    fi
    local url="https://raw.githubusercontent.com"
    url="${url}/Homebrew/install/master/install.sh"
    echo "*** Installing Homebrew..."
    /bin/bash -c "$(curl -fsSL ${url})" ||
        {
            error "Failed to install Homebrew"
            exit 1
        }
}

# Install Ansible
install_ansible() {
    debug "install Ansible"
    if is_true "${is_macos}"; then
        install_ansible_on_macos
    elif is_true "${is_linux}"; then
        install_ansible_on_linux
    else
        error "Your system is not supported"
        exit 1
    fi
}

# Upgrade existing Ansible installation to the latest version
upgrade_ansible() {
    debug "upgrade Ansible"
    if is_true "${is_macos}"; then
        upgrade_ansible_on_macos
    elif is_true "${is_linux}"; then
        error "upgrading Ansible on Linux is not supported"
    else
        error "Your system is not supported"
        exit 1
    fi
}

# Is the installed Ansible version outdated
is_ansible_outdated() {
    if ! is_ansible_installed; then
        debug "ansible not installed, not marking it as outdated"
        return 1
    fi
    # Check Homebrew installation
    if is_ansible_homebrew_enabled; then
        local outdated
        outdated=$(brew outdated -q ansible)
        if [ -n "${outdated}" ]; then
            debug "outdated Ansible Homebrew formula found"
            return 0
        fi
    fi
    # Not supporting Linux or PyPI version checking
    return 1
}

# Is Ansible installed on the PATH or in the custom location
is_ansible_installed() {
    # Check Homebrew installation
    if is_ansible_homebrew_enabled; then
        # Fail if Ansible formula is not found
        if [ "$(brew --prefix ansible)" == "" ]; then
            debug "brew --prefix ansible is empty"
            return 1
        fi
        debug "ansible Homebrew formula found"
    fi
    # Fail if 'ansible --version' doesn't work
    local version
    version=$(ansible_exec ansible --version 2>/dev/null)
    if [ -z "${version}" ]; then
        debug "ansible --version is empty"
        return 1
    fi
}

# Install Ansible on Linux
install_ansible_on_linux() {

    if is_ansible_installed; then
        return 0
    fi

    echo "*** Install Ansible on Linux..."

    # Enable APT installation as the default option if neither APT or
    # PyPI installation option have been set or if PyPI has been disabled.
    if [ -z "${ansible_apt_enabled}" ]; then
        if [ -z "${ansible_pypi_enabled}" ]; then
            ansible_apt_enabled=true
        elif is_ansible_pypi_disabled; then
            ansible_apt_enabled=true
        fi
    fi

    # Install Ansible with APT
    if is_ansible_apt_enabled; then
        if is_true "${is_ubuntu}"; then
            if install_ansible_with_apt_on_ubuntu; then
                return 0
            fi
        elif is_true "${is_debian}"; then
            if install_ansible_with_apt_on_debian; then
                return 0
            fi
        elif is_true "${is_pengwin}"; then
            if install_ansible_with_apt_on_debian; then
                return 0
            fi
        else
            error "Your system is not supported"
            exit 1
        fi
    fi

    # Fallback to PyPI installation unless explicitly disabled
    if [ -z "${ansible_pypi_enabled}" ]; then
        echo "*** Enabled PyPI installation"
        ansible_pypi_enabled=true
    fi

    # Install Ansible from PyPI package
    if is_ansible_pypi_enabled; then
        if install_ansible_with_pip; then
            return 0
        fi
    fi

    error "Failed to install Ansible"
    exit 1
}

# Upgrade exisging Ansible installation on macOS
upgrade_ansible_on_macos() {
    debug "upgrade Ansible on macOS"

    configure_ansible_on_macos

    if ! is_ansible_outdated; then
        debug "outdated Ansible version not detected"
        return 0
    fi

    if is_ansible_pypi_enabled; then
        error "upgrading Ansible PyPI packages is not supported"
        return 1
    fi
    if ! is_ansible_homebrew_enabled; then
        error "upgrading Ansible on macOS requires Homebrew"
        return 1
    fi
    if ! upgrade_ansible_with_homebrew; then
        error "failed to upgrade Ansible"
        return 1
    fi
}

# Upgrade Ansible installed with Homebrew
upgrade_ansible_with_homebrew() {
    echo "*** Upgrading Ansible with Homebrew..."
    brew upgrade ansible ||
        {
            error "Failed to upgrade Ansible with Homebrew"
            exit 1
        }
}

# Configure Ansible on macOS
configure_ansible_on_macos() {
    debug "configure Ansible on macOS"
    # Enable Homebrew installation as the default option if neither Homebrew or
    # PyPI installation option have been set or if PyPI has been disabled.
    if [ -z "${ansible_homebrew_enabled}" ]; then
        if [ -z "${ansible_pypi_enabled}" ]; then
            debug "PyPI installation is not enabled"
            ansible_homebrew_enabled=true
        elif is_ansible_pypi_disabled; then
            debug "PyPI installation is disabled"
            ansible_homebrew_enabled=true
        fi
    fi
}

# Install Ansible on macOS
install_ansible_on_macos() {

    debug "install Ansible on macOS"

    configure_ansible_on_macos

    if is_ansible_installed; then
        debug "existing Ansible version found, not installing..."
        return 0
    fi

    echo "Install Ansible on macOS..."

    # Install Ansible from Homebrew
    if is_ansible_homebrew_enabled; then
        debug "install Ansible from Homebrew"
        if is_true "${is_macos}"; then
            if install_ansible_with_homebrew; then
                return 0
            fi
        else
            error "Your system is not supported"
            exit 1
        fi
    fi

    # Fallback to PyPI installation unless explicitly disabled
    if [ -z "${ansible_pypi_enabled}" ]; then
        echo "*** Enabled PyPI installation"
        ansible_pypi_enabled=true
    fi

    # Install Ansible from PyPI package
    if is_ansible_pypi_enabled; then
        if install_ansible_with_pip; then
            return 0
        fi
    fi

    error "Failed to install Ansible"
    exit 1
}

# Install Ansible with Homebrew
install_ansible_with_homebrew() {
    echo "*** Installing Ansible with Homebrew..."
    brew install ansible ||
        {
            error "Failed to install Ansible with Homebrew"
            exit 1
        }
}

# Uninstall Ansible from Homebrew
uninstall_ansible_with_homebrew() {
    echo "*** Uninstalling Ansible with Homebrew..."
    brew uninstall ansible ||
        {
            error "Failed to uninstall Ansible with Homebrew"
            exit 1
        }

}

# Get APT package install candidate
apt_install_candidate() {
    local package=$1
    local candidate
    candidate=$(apt-cache policy "${package}" | grep 'Candidate:' | sed 's/[[:space:]]*Candidate:[[:space:]]*//')
    if [ -n "${candidate}" ]; then
        echo "${candidate}" | cut -d- -f1
    fi
}

# Instal Ansible with PIP
install_ansible_with_pip() {
    local package_version

    if [ "${ansible_version}" == "2.7" ]; then
        package_version="<2.8"
    elif [ "${ansible_version}" == "2.8" ]; then
        package_version="!=2.8.6,<2.9"
    elif [ "${ansible_version}" == "2.9" ]; then
        package_version="<2.10"
    else
        error "Unsupported Ansible version ${ansible_version}"
        return 1
    fi

    if is_true "${ansible_pyenv_enabled}"; then
        if [ -n "${ansible_pyenv}" ]; then
            install_ansible_in_pyenv \
                "${package_version}" \
                "${ansible_pyenv}" || return 1
            return 0
        fi
    fi

    if is_true "${ansible_virtualenv_enabled}"; then
        if [ -n "${ansible_virtualenv}" ]; then
            install_ansible_in_virtualenv \
                "${package_version}" \
                "${ansible_virtualenv}" || return 1
            return 0
        fi
    fi

    error "Couldn't find local pyenv or virtualenv environments"
    return 1
}

# Install Ansible in the given pyenv version
install_ansible_in_pyenv() {
    local package_version="$1"
    local pyenv_version="$2"

    if ! command -v pyenv >/dev/null; then
        error "pyenv not found"
        return 1
    fi

    echo "*** Install Ansible PyPI (ansible${package_version}) in ${pyenv_version}"

    pyenv_exec "${pyenv_version}" \
        pip install "ansible${package_version}" || {
        error "Failed to install Ansible in ${pyenv_version}"
        return 1
    }

    PYENV_VERSION="${pyenv_version}" pyenv rehash

    echo "*** Ansible ${ansible_version} installed in ${pyenv_version}"
    ansible_pypi_enabled=true
}

# Check if virtualenv command is installed
is_virtualenv_installed() {
    if ! command -v virtualenv >/dev/null; then
        return 1
    fi
    if [ -z "$(virtualenv --version 2>/dev/null)" ]; then
        return 1
    fi
}

# Create virtualenv in given directory if it doesn't already exist
create_virtualenv() {
    local virtualenv_path="$2"

    if [ ! -d "${virtualenv_path}" ]; then

        if ! is_virtualenv_installed; then
            error "Python virtuelenv command not found"
            return 1
        fi

        virtualenv "${virtualenv_path}" || {
            error "Failed to create virtualenv in ${virtualenv_path}"
            return 1
        }
    fi
}

# Install Ansible in a virtualenv
install_ansible_in_virtualenv() {
    local package_version="$1"
    local virtualenv_path="$2"

    create_virtualenv "${virtualenv_path}" || return 1

    echo "*** Install Ansible PyPI (ansible${package_version}) in ${virtualenv_path}"

    virtualenv_exec "${virtualenv_path}" \
        pip install "ansible${package_version}" || {
        error "Failed to install Ansible in ${virtualenv_path}"
        return 1
    }

    echo "*** Ansible ${ansible_version} installed into ${virtualenv_path}"
    ansible_pypi_enabled=true
}

# Install missing APT package
install_apt_package() {
    local package="$1"
    debug "APT package ${package} is required"
    if ! is_apt_package_installed "${package}"; then
        echo "*** Install ${package}..."
        sudo apt-get install -y "${package}" || {
            error "Failed to install ${package}"
            return 1
        }
    fi
}

# Remove APT package if installed
remove_apt_package() {
    local package="$1"
    if is_apt_package_installed "${package}"; then
        echo "*** Remove ${package} APT package..."
        sudo apt-get remove -y "${package}" || {
            error "Failed to remove ${package}"
            return 1
        }
    fi
}

# Remove Ansible installations
remove_ansible_installations() {

    # Skip if not enabled
    if ! is_true "${remove_ansible}"; then
        return
    fi

    # Remove any local virtuelenv directories
    remove_ansible_virtualenv

    # Find local pyenv version
    if command -v pyenv >/dev/null; then
        local pyenv_version
        if [ -n "${ansible_pyenv}" ]; then
            pyenv_version="${ansible_pyenv}"
        elif [ -e ".python-version" ]; then
            # Check .python-version file even if PyPi install is disabled
            pyenv_version=$(cat .python-version)
        fi
    fi

    # Uninstall Ansible package from the pyenv environment
    if [ -n "${pyenv_version}" ]; then
        local pyenv_installed
        pyenv_installed=$(pyenv_exec "${pyenv_version}" pip freeze | grep "^ansible==")
        if [ -n "${pyenv_installed}" ]; then
            echo "*** Uninstall ansible PyPI from pyenv version ${pyenv_version}"
            pyenv_exec "${pyenv_version}" pip uninstall -y ansible
        fi
    fi

    # Remove Homebrew installations on macOS
    if is_true "${is_macos}"; then
        uninstall_ansible_with_homebrew
    fi

    # Remove APT installations on Ubuntu and Debian-based systems
    if is_true "${is_ubuntu}" || is_true "${is_pengwin}" || is_true "${is_debian}"; then
        remove_apt_package "ansible"
        remove_ansible_apt_sources_list
    fi
}

# Install Ansible PPA on Ubuntu
install_ansible_ppa_on_ubuntu() {

    # Do not add PPA if it already exists
    if compgen -G "/etc/apt/sources.list.d/ansible*.list" >/dev/null; then
        local deb_url="http://ppa.launchpad.net/${ansible_ppa}/ubuntu"
        if grep -q "^deb ${deb_url}" /etc/apt/sources.list.d/ansible*.list; then
            return 0
        fi
    fi

    install_apt_package "software-properties-common"

    echo "*** Add ${ansible_ppa} PPA repository..."
    sudo apt-add-repository -y "ppa:${ansible_ppa}"

    add_ansible_ppa_key
}

# Remove all Ansible sources list files
remove_ansible_apt_sources_list() {
    local update_apt_cache
    for apt_list in /etc/apt/sources.list.d/ansible*.list; do
        if [ -e "${apt_list}" ]; then
            echo "Remove ${apt_list}"
            sudo rm -f "${apt_list}" || {
                error "Failed to remove ${apt_list}"
                exit 1
            }
            update_apt_cache=1
        fi
    done
    if [ "${update_apt_cache}" == "1" ]; then
        echo "*** Update APT cache..."
        sudo apt-get update || {
            error "failed to update APT cache"
            exit 1
        }
    fi
}

# Remove local virtualenv when using OS installation method
remove_ansible_virtualenv() {
    # Deactivate current virtualenv before deleting it
    if [ -n "${VIRTUAL_ENV}" ]; then
        if [ "$(type -f deactivate)" == "function" ]; then
            deactivate
        fi
    fi
    ## Remove virtualenv directory
    if [ -d "${ansible_virtualenv}" ]; then
        echo "*** Removing virtualenv in '${ansible_virtualenv}'"
        rm -rf "${ansible_virtualenv}"
    fi
}

# Install Ansible with APT on Ubuntu
install_ansible_with_apt_on_ubuntu() {

    if [ "${distrib_release}" == "focal" ]; then
        echo "*** Do not use PPA on Ubuntu 20.04 LTS"
    else
        install_ansible_ppa_on_ubuntu
    fi

    if ! install_ansible_apt "${ansible_version}"; then
        error "Couldn't install Ansible ${ansible_version} from APT"
        return 1
    fi

    echo "*** Ansible ${ansible_version} installed"

    remove_ansible_virtualenv
}

# Install Ansible PPA on Debian
install_ansible_ppa_on_debian() {

    install_apt_package "gnupg2"

    local deb_url="http://ppa.launchpad.net/${ansible_ppa}/ubuntu"
    local deb_release="trusty"
    local apt_list="/etc/apt/sources.list.d/ansible.list"

    if [ -e "${apt_list}" ]; then
        # Do nothing if the correct PPA URL exists in the APT sources list file
        if grep -q "^deb ${deb_url}" "${apt_list}"; then
            return 0
        fi
        echo "*** Updating ${ansible_ppa} PPA repository..."
        sudo sh -c "echo 'deb ${deb_url} ${deb_release} main' > ${apt_list}"
    else
        echo "*** Add ${ansible_ppa} PPA repository..."
        sudo sh -c "echo 'deb ${deb_url} ${deb_release} main' > ${apt_list}"
    fi

    add_ansible_ppa_key
}

# Install Ansible with APT on Debian
install_ansible_with_apt_on_debian() {

    install_ansible_ppa_on_debian

    if ! install_ansible_apt "${ansible_version}"; then
        error "Couldn't install Ansible ${ansible_version} from APT"
        return 1
    fi

    echo "*** Ansible ${ansible_version} installed"

    remove_ansible_virtualenv
}

# Install Ansible APT package
install_ansible_apt() {
    local version=$1

    echo "*** Update APT cache..."
    sudo apt-get update || {
        error "failed to update APT cache"
        exit 1
    }

    local candidate
    candidate=$(apt_install_candidate "ansible")
    if [ "${candidate}" == "2.8.6" ]; then
        error "WARNING: Not installing Ansible version ${candidate} from APT"
        return 1
    fi

    echo "*** Installing Ansible ${version} from APT..."
    sudo apt-get install -y "ansible=${version}*" || {
        error "Failed to install ansible=${version}*"
        return 1
    }
}

# Check if an APT package has been installed
is_apt_package_installed() {
    local package="$1"
    status=$(dpkg-query --show --showformat='${db:Status-Status}\n' "${package}")
    if [ "${status}" == "installed" ]; then
        return 0
    else
        return 1
    fi
}

# Add Ansible PPA signing key
add_ansible_ppa_key() {
    echo "*** Add Ansible PPA signing key..."
    gpg --keyserver keyserver.ubuntu.com --recv "${ansible_ppa_key_id}"
    gpg --export --armor "${ansible_ppa_key_id}" | sudo apt-key add -
}

# Remove Ansible PPA signing key
remove_ansible_ppa_key() {
    echo "*** Remove Ansible PPA signing key..."
    sudo apt-key del "${ansible_ppa_key_id}"
}

# Install Ansible roles
install_ansible_roles() {

    # Skip if install_roles is not enabled
    if ! is_true "${install_roles}"; then
        return
    fi

    local ansible_roles_opts=""

    if is_true "${install_roles_force}"; then
        ansible_roles_opts="${ansible_roles_opts} --force"
    fi

    echo "*** Installing Ansible roles..."
    # shellcheck disable=SC2086
    ansible_exec ansible-galaxy install \
        -r requirements.yml \
        -p ${ansible_roles} \
        ${ansible_roles_opts} ||
        {
            error "Failed to install Ansible roles"
            exit 1
        }
}

# Update Ansible roles
update_ansible_roles() {

    # Skip if update_roles is not enabled
    if ! is_true "${update_roles}"; then
        return
    fi

    echo "*** Installing Python requirements..."
    pip install -r requirements.txt || {
        error "Failed to install required packages"
        exit 1
    }

    echo "*** Updating Ansible roles..."
    ./scripts/update_roles.py || {
        error "Failed to update Ansible roles"
        exit 1
    }
}

# Detect if we're running macOS or Linux
detect_os() {
    if test "$(uname)" = "Darwin"; then
        debug "macOS found"
        is_macos=1
        is_linux=0
    elif test "$(uname)" = "Linux"; then
        debug "Linux found"
        is_linux=1
        is_macos=0
        detect_ubuntu
        detect_debian
        detect_pengwin
        detect_wsl
    else
        error "Your system is not supported"
        exit 1
    fi
}

# Detect Windows Subsystem for Linux
detect_wsl() {
    if [[ -d "/run/WSL" ]]; then
        echo "*** Windows Subsystem for Linux (WSL2) detected"
        is_wsl=1
        wsl_version='WSL2'
        return
    fi
    if grep -q Microsoft /proc/version; then
        echo "*** Windows Subsystem for Linux (WSL1) detected"
        is_wsl=1
        wsl_version='WSL1'
        return
    fi
    is_wsl=0
}

# Detect Ubuntu
detect_ubuntu() {
    if ! test -f /etc/lsb-release; then
        is_ubuntu=0
        return
    fi
    if ! grep -q Ubuntu /etc/lsb-release; then
        is_ubuntu=0
        return
    fi
    echo "*** Ubuntu detected"
    is_ubuntu=1
    local codename
    codename=$(grep "DISTRIB_CODENAME=" /etc/lsb-release | cut -d= -f2)
    if [ -n "${codename}" ]; then
        debug "release: ${codename}"
        # shellcheck disable=SC2034
        distrib_release="${codename}"
    fi
}

# Detect Debian
detect_debian() {
    if ! test -f /etc/os-release; then
        is_debian=0
        return
    fi
    if ! grep -q Debian /etc/os-release; then
        is_debian=0
        return
    fi
    echo "*** Debian detected"
    is_debian=1
    local codename
    codename=$(grep "VERSION_CODENAME=" /etc/os-release | cut -d= -f2)
    if [ -n "${codename}" ]; then
        debug "release: ${codename}"
        # shellcheck disable=SC2034
        distrib_release="${codename}"
    fi
}

# Detect Pengwin
detect_pengwin() {
    if test -f /etc/os-release; then
        is_pengwin=0
        return
    fi
    if ! grep -q Pengwin /etc/os-release; then
        is_pengwin=0
        return
    fi
    echo "*** Pengwin detected"
    is_pengwin=1
}

# Execute command with pyenv version
pyenv_exec() {
    local args=("$@")
    # The first argument is the pyenv version
    local pyenv_version="${args[0]}"
    if ! command -v pyenv >/dev/null; then
        error "pyenv not installed"
        exit 1
    fi
    # shellcheck disable=SC2068
    PYENV_VERSION="${pyenv_version}" pyenv exec "${args[@]:1}"
}

# Execute command in virtualenv
virtualenv_exec() {
    local args=("$@")
    # The first argument is the virtualenv path
    local virtualenv_path="${args[0]}"
    if [ -d "${virtualenv_path}" ]; then
        error "${virtualenv_path} not found"
        exit 1
    fi
    # shellcheck disable=SC2068
    PATH="${virtualenv_path}/bin:$PATH" ${args[@]:1}
}

# Execute Ansible commands in the correct environment
ansible_exec() {
    # When double quoted, "$@" expands to separate strings - "$1" "$2" "$n".
    local args=("$@")

    # Custom path to Ansible binaries
    local ansible_path

    # Get Homebrew Ansible installation prefix
    if is_ansible_homebrew_enabled; then
        debug "ansible_exec: Ansible Homebrew enabled"
        local prefix
        prefix="$(brew --prefix ansible)"
        debug "ansible_exec: Ansible prefix: ${prefix}"
        if [ -n "${prefix}" ] && [ -d "${prefix}/bin" ]; then
            ansible_path="${prefix}/bin"
            debug "ansible_exec: use Ansible from Homebrew"
        fi
    fi

    # Get pyenv version
    local pyenv_version
    if is_true "${ansible_pyenv_enabled}"; then
        if [ -n "${ansible_pyenv}" ]; then
            pyenv_version="${ansible_pyenv}"
        fi
    fi

    # Get virtualenv path
    local virtualenv_path
    if is_true "${ansible_virtualenv_enabled}"; then
        if [ -n "${ansible_virtualenv}" ] && [ -d "${ansible_virtualenv}" ]; then
            virtualenv_path="${ansible_virtualenv}"
        fi
    fi

    if [ -n "${ansible_path}" ]; then
        debug "execute with the custom path ${ansible_path}"
        # shellcheck disable=SC2068
        PATH="${ansible_path}:$PATH" ${args[@]}
    elif [ -n "${pyenv_version}" ]; then
        debug "execute in the local pyenv ${pyenv_version}"
        # shellcheck disable=SC2068
        pyenv_exec "${pyenv_version}" "${args[@]}"
    elif [ -n "${virtualenv_path}" ]; then
        debug "execute in the local virtualenv ${virtualenv_path}"
        # shellcheck disable=SC2068
        virtualenv_exec "${virtualenv_path}" "${args[@]}"
    else
        debug "execute with system PATH"
        # shellcheck disable=SC2068
        ${args[@]}
    fi
}

# Run Ansible playbook
run_ansible_playbook() {

    if [ -n "${ansible_executable}" ]; then
        echo "*** Use ${ansible_executable} as Ansible executable"
        export ANSIBLE_EXECUTABLE="${ansible_executable}"
    fi

    # shellcheck disable=SC2046
    ansible_exec ansible-playbook "${ansible_playbook}" \
        $(ansible_inventory) \
        $(run_ansible_playbook_opts)
}

# Options to pass to ansible-playbook
run_ansible_playbook_opts() {

    local ansible_opts=()

    if [ "${distrib_release}" == "focal" ] || [ "${distrib_release}" == "bionic" ]; then
        ansible_opts+=("-e ansible_python_interpreter=auto")
    fi

    if [ -e "${local_vars_file}" ]; then
        ansible_opts+=("--extra-vars @${local_vars_file}")
    fi

    if is_true "${ansible_verbose}"; then
        ansible_opts+=("-v")
    fi

    if [ "${ansible_tags}" != "" ]; then
        ansible_opts+=("--tags=${ansible_tags}")
    fi

    if [ "${ansible_skip_tags}" != "" ]; then
        ansible_opts+=("--skip-tags=${ansible_skip_tags}")
    fi

    # Variables to pass to ansible-playbook
    local ansible_vars=()

    if is_true "${is_linux}"; then
        if is_true "${is_wsl}"; then
            ansible_vars+=("\"is_wsl\":true")
            ansible_vars+=("\"wsl_version\":${wsl_version}")
        else
            ansible_vars+=("\"is_wsl\":false")
        fi
    fi

    ansible_vars+=("\"user_home\":\"${HOME}\"")
    ansible_vars+=("\"user_name\":\"${USER}\"")

    if [ "${#ansible_vars[@]}" -gt "0" ]; then
        local extra_vars
        extra_vars=$(printf ",%s" "${ansible_vars[@]}")
        extra_vars="{${extra_vars:1}}"
        ansible_opts+=("-e ${extra_vars}")
    fi

    if is_true "${ansible_become}"; then
        sudo true || {
            error "sudo failed"
            exit 1
        }
        ansible_opts+=("--become")
    fi

    echo "${ansible_opts[@]}"
}

# Check Ansible playbook syntax
check_ansible_playbook_syntax() {
    # shellcheck disable=SC2046
    ansible_exec ansible-playbook ${ansible_playbook} \
        $(ansible_inventory) \
        --syntax-check
}

# Ansible inventory options
ansible_inventory() {
    local inventory_opts=()
    if [ "${deploy_env}" != "" ]; then
        deploy_env_err="Could not find inventory file for ${deploy_env}"
        [ -e "inventory/${deploy_env}" ] ||
            {
                error "${deploy_env_err}"
                exit 1
            }
        inventory_opts+=("-i inventory/${deploy_env}")
    fi
    echo "${inventory_opts[@]}"
}

# List tags available in Ansible playbooks
ansible_playbook_list_tags() {
    # shellcheck disable=SC2046
    ansible_exec ansible-playbook ${ansible_playbook} \
        $(ansible_inventory) \
        --list-tags
}

# Setup dependencies
setup_dependencies() {

    if is_true "${is_macos}"; then
        install_macos_dependencies
    elif is_true "${is_linux}"; then
        install_linux_dependencies
    else
        error "Your system is not supported"
        exit 1
    fi

    if ! is_ansible_installed; then
        error "Ansible not found"
        exit 1
    fi
}

# Configure options on macOS
configure_macos() {
    # Do not use sudo on macOS
    ansible_become=0
    # Disable APT installation source on macOS
    ansible_apt_enabled=false
}

# Configure options on Linux
configure_linux() {
    # Enable sudo on Linux
    ansible_become=1
    # Disable Homebrew installation source on Linux
    ansible_homebrew_enabled=false
    # Do not install Xcode or Homebrew on Linux
    install_homebrew=0
    install_xcode=0
    # Use bash on WSL to avoid issues with spaces on the PATH
    if is_true "${is_wsl}"; then
        ansible_executable=$(command -v /bin/bash 2>/dev/null)
    fi
}

# Check for known issues with macOS upgrade
configure_xcode() {
    if ! is_true "${is_macos}"; then
        return
    fi
    if ! command -v gcc >/dev/null; then
        echo "*** GCC doesn't exist, install Xcode..."
        install_xcode=1
        return
    fi
    if ! command -v make >/dev/null; then
        echo "*** GNU make not found, install Xcode..."
        install_xcode=1
        return
    fi
    if ! make --version >/dev/null; then
        echo "*** GNU make is not working, install Xcode..."
        install_xcode=1
        return
    fi
    install_xcode=0
}

# Configure options
configure_options() {
    if is_true "${is_macos}"; then
        configure_macos
        configure_xcode
    elif is_true "${is_linux}"; then
        configure_linux
    else
        error "Your system is not supported"
        exit 1
    fi
}

# Is Ansible Homebrew installation enabled
is_ansible_homebrew_enabled() {
    # Homebrew installation is only supported on macOS
    is_true "${is_macos}" || return 1
    is_true "${ansible_homebrew_enabled}" || return 1
}

# Is Ansible PyPI installation enabled?
is_ansible_pypi_enabled() {
    is_true "${ansible_pypi_enabled}" || return 1
}

# Is Ansible PyPI installation disabled?
is_ansible_pypi_disabled() {
    is_false "${ansible_pypi_enabled}" || return 1
}

# Is Ansible APT installation enabled?
is_ansible_apt_enabled() {
    # Homebrew installation is not supported on macOS
    is_true "${is_macos}" && return 1
    is_true "${ansible_apt_enabled}" || return 1
}

# Is variable set to a true value?
is_true() {
    local value="$1"
    if [ -z "${value}" ]; then
        return 1
    fi
    if [ "${value}" == "true" ]; then
        return 0
    fi
    if [ "${value}" == "1" ]; then
        return 0
    fi
    return 1
}

# Is variable set to a false value?
is_false() {
    local value="$1"
    if [ -z "${value}" ]; then
        return 1
    fi
    if [ "${value}" == "false" ]; then
        return 0
    fi
    if [ "${value}" == "0" ]; then
        return 0
    fi
    return 1
}

# Configure Ansible PyPI installation options
configure_pypi() {

    # Skip virtualenv if using Homebrew
    if is_ansible_homebrew_enabled; then
        return 0
    fi

    # Skip virtualenv configuration if we've disabled PyPI installation
    if is_ansible_pypi_disabled; then
        return 0
    fi

    # Enable PyPI installation if local virtualenv is found
    configure_virtualenv

    # Enable PyPI installation if local pyenv is found
    configure_pyenv
}

configure_virtualenv() {

    # Check if virtualenv is installed
    if ! command -v virtualenv >/dev/null; then
        ansible_virtualenv_enabled=false
        return 1
    fi

    # Do not configure if virtualenv is disabled
    if is_false "${ansible_virtualenv_enabled}"; then
        return 1
    fi

    # Install from PyPI if local virtualenv is found
    if [ -n "${ansible_virtualenv}" ] && [ -d "${ansible_virtualenv}" ]; then
        echo "*** Use virtualenv in ${ansible_virtualenv}"
        ansible_pypi_enabled=true
        ansible_virtualenv_enabled=true
    fi
}

# Configure pyenv installation options
configure_pyenv() {

    # Check if pyenv is installed
    if ! command -v pyenv >/dev/null; then
        ansible_pyenv_enabled=false
        return 1
    fi

    # Do not configure if pyenv is disabled
    if is_false "${ansible_pyenv_enabled}"; then
        return 1
    fi

    # Use local pyenv version if found
    if [ -e ".python-version" ]; then
        ansible_pypi_enabled=true
        ansible_pyenv_enabled=true
        ansible_pyenv="$(cat .python-version)"
        echo "*** Use pyenv version ${ansible_pyenv}"
    fi
}

# Check for upgrades
check_upgrades() {
    if ! is_true "${check_os_upgrades}"; then
        return 0
    fi
    if is_true "${is_ubuntu}"; then
        check_dist_upgrades
    elif is_true "${is_pengwin}"; then
        check_dist_upgrades
        check_pengwin_upgrades
    elif is_true "${is_macos}"; then
        check_brew_upgrades
    fi
}

# Check for distribution upgrades on Debian-based systems
check_dist_upgrades() {
    echo "*** Checking for distribution upgrade..."
    if [ -f "/etc/apt/.dist-upgrade" ]; then
        echo "A distribution upgrade is available."
    fi
}

# Check for Pengwin core upgrades
check_pengwin_upgrades() {
    echo "*** Checking for Pengwin core upgrades..."
    local upgrades=""
    upgrades="$(apt-get -s upgrade --show-upgraded --assume-no | grep pengwin)"
    if [[ "${upgrades}" == *"pengwin"* ]]; then
        echo "Pengwin core package upgrades found."
        echo "Use 'pengwin-setup' to upgrade them."
    fi
}

# Check for Homebrew upgrades
check_brew_upgrades() {
    local outdated
    outdated="$(brew outdated -q)"
    if [ -n "${outdated}" ]; then
        echo "Outdated Homebrew packages found"
        echo "Run 'brew outdated' to list them and 'brew upgrade' to upgrade"
    fi
}

# Check user is not root
check_user() {
    if [ "$USER" == "root" ]; then
        error "FAILED: USER is root"
        exit 1
    fi
    if [ "$HOME" == "/root" ]; then
        error "FAILED: HOME set to /root"
        exit 1
    fi
}

print_installed_versions() {
    if is_true "${print_versions}"; then
        python --version
        ansible --version
    fi
}

# Parse command line arguments
POSITIONAL=()
while [[ $# -gt 0 ]]; do
    key="$1"
    case $key in
        --reinstall-ansible)
            install_ansible=1
            remove_ansible=1
            shift
            ;;
        --enable-ansible-pypi)
            ansible_pypi_enabled=true
            shift
            ;;
        --disable-ansible-pypi)
            ansible_pypi_enabled=false
            shift
            ;;
        --disable-ansible-pyenv)
            ansible_pyenv_enabled=false
            shift
            ;;
        --disable-ansible-virtualenv)
            ansible_virtualenv_enabled=false
            shift
            ;;
        --enable-ansible-apt)
            ansible_apt_enabled=true
            shift
            ;;
        --disable-ansible-apt)
            ansible_apt_enabled=false
            shift
            ;;
        --enable-ansible-homebrew)
            ansible_homebrew_enabled=true
            shift
            ;;
        --disable-ansible-homebrew)
            ansible_homebrew_enabled=false
            shift
            ;;
        --install-ansible)
            install_ansible=1
            shift
            ;;
        --no-run-playbook)
            run_playbook=0
            shift
            ;;
        --no-install-ansible)
            install_ansible=0
            shift
            ;;
        --no-install-roles)
            install_roles=0
            shift
            ;;
        --upgrade-ansible)
            upgrade_ansible=1
            shift
            ;;
        --update-roles)
            update_roles=1
            shift
            ;;
        --verbose)
            ansible_verbose=1
            shift
            ;;
        --print-versions)
            print_versions=1
            shift
            ;;
        *)                     # unknown option
            POSITIONAL+=("$1") # save it in an array for later
            shift              # past argument
            ;;
    esac
done
set -- "${POSITIONAL[@]}" # restore positional parameters

# Parse command line options
while getopts ":hfnqlsvut:i:" opt; do
    case $opt in
        h)
            show_help
            exit 0
            ;;
        f)
            install_roles_force=1
            ;;
        n)
            run_playbook=0
            ;;
        q)
            check_os_upgrades=0
            install_roles=0
            install_ansible=0
            install_homebrew=0
            ;;
        l)
            list_tags=1
            run_playbook=0
            ;;
        s)
            syntax_check=1
            run_playbook=0
            ;;
        v)
            ansible_verbose=1
            print_versions=1
            ;;
        u)
            update_roles=1
            ;;
        i)
            ansible_skip_tags=$OPTARG
            ;;
        t)
            ansible_tags=$OPTARG
            ;;
        \?)
            error "Invalid option: -$OPTARG"
            show_help
            exit 1
            ;;
        :)
            error "Option -$OPTARG requires an argument"
            exit 1
            ;;
    esac
done

# Detect system properties
detect_os

# Configure options
configure_options

# Configure Ansible installation options if using PyPI and virtualenv
configure_pypi

# Remove existing Ansible installations
remove_ansible_installations

# Setup dependencies
setup_dependencies

# Check for upgrades
check_upgrades

# Check current user is not root
check_user

# Display installed versions
print_installed_versions

# Check installed Ansible version meets the requirements
check_installed_ansible_version

# Update Ansible role versions in requirements.yml
update_ansible_roles

# Install Ansile roles
install_ansible_roles

# Run a setup command
if [ "${list_tags}" == "1" ]; then
    ansible_playbook_list_tags
elif [ "${syntax_check}" == "1" ]; then
    check_ansible_playbook_syntax
elif [ "${run_playbook}" == "1" ]; then
    run_ansible_playbook
fi