ethd

#!/usr/bin/env bash
set -Eeuo pipefail

__project_name="X Docker"
__app_name="X node"
__sample_service="X-geth"
__docker_exe="docker"
__compose_exe="docker compose"
__compose_upgraded=0

# Also adjust version() and __env_migrate for your chain, look for the word "Adjust" below

version() {
# script version
  grep "^This is" README.md
  echo
  __var="COMPOSE_FILE"
  __value=$(__get_value_from_env "${__var}" "${__env_file}")
# Client versions
# Adjust for your clients and how to check their version
  case "${__value}" in
    *x.yml* )
      __docompose exec x-geth x-geth version
      ;;&
  esac
}


__prep_conffiles() {
  # Adjust - this is where sample files would be copied to config files that are meant to be bind-mounted
  return
}


__env_migrate() {
  if [ ! -f "${__env_file}" ]; then
    return 0
  fi

# Adjust these vars to your project
  __all_vars=( COMPOSE_FILE NETWORK SNAPSHOT LOG_LEVEL DOMAIN RPC_HOST RPC_LB WS_HOST WS_LB RPC_PORT WS_PORT P2P_PORT \
             SCRIPT_TAG X_SRC_BUILD_TARGET X_SRC_REPO X_DOCKER_TAG X_DOCKER_REPO X_DOCKERFILE )
  __old_vars=( )
  __new_vars=( )

  __var=ENV_VERSION
  __target_ver=$(__get_value_from_env "${__var}" "default.env")
  __source_ver=$(__get_value_from_env "${__var}" "${__env_file}")

  if [[ "${__target_ver}" -le "${__source_ver}" ]]; then # No changes in template, do nothing
    return 0
  fi

  echo "Migrating ${__env_file} to version ${__target_ver}"
  ${__as_owner} cp "${__env_file}" "${__env_file}".source
  __during_migrate=1
  __migrated=1
  ${__as_owner} cp default.env "${__env_file}"
  # Migrate over user settings
  for __var in "${__all_vars[@]}"; do
    __value=$(__get_value_from_env "${__var}" "${__env_file}.source")
# Adjust for vars that are possibly empty
    if [ -n "${__value}" ] || [ "${__var}" = "SNAPSHOT" ]; then
      # Handle & gracefully, as well as multi-line
      __update_value_in_env "${__var}" "$__value" "${__env_file}"
    fi
  done
  # Move value from old variable name(s) to new one(s)
  for __index in "${!__old_vars[@]}"; do
    __var=${__old_vars[__index]}
    __value=$(__get_value_from_env "${__var}" "${__env_file}.source")
    if [ -n "${__value}" ]; then
      __update_value_in_env "${__new_vars[__index]}" "$__value" "${__env_file}"
    fi
  done
  __during_migrate=0
}


__dodocker() {
  $__docker_sudo $__docker_exe "$@"
}


__docompose() {
# I want word splitting here
# shellcheck disable=SC2086
  $__docker_sudo $__compose_exe "$@"
}


__get_value_from_env() {
    local __var_name="$1"
    local __env_file="$2"
    local __value

    __value=$(awk -v var="$__var_name" '
        BEGIN { __found = 0; __value = "" }

        # Skip empty lines and comments
        /^#|^\s*$/ {
            next
        }

        # Match single-line unquoted value
        $0 ~ "^[ \t]*"var"=[^\"].*$" {
            gsub("^[ \t]*"var"=", "")
            gsub(/^[ \t]*|[ \t]*$/, "", $0)
            __value = $0
            __found = 1
            exit
        }

        # Match a quoted single-line value
        $0 ~ "^[ \t]*"var"=\"[^\"]*\"[ \t]*$" {
            gsub("^[ \t]*"var"=\"", "")
            gsub(/"[ \t]*$/, "", $0)
            __value = "\"" $0 "\""
            __found = 1
            exit
        }

        # Match the start of a multi-line value (with opening quote)
        $0 ~ "^[ \t]*"var"=\"[^\"]*$" {
            gsub("^[ \t]*"var"=\"", "")
            __value = "\"" $0 "\n"
            __found = 1
            next
        }

        # Continue collecting lines for a multi-line value
        __found && !/"[ \t]*$/ {
            __value = __value $0 "\n"
            next
        }

        # End of a multi-line value (with closing quote)
        __found && /"[ \t]*$/ {
            gsub(/[ \t]*"[ \t]*$/, "")
            __value = __value $0 "\""
            __found = 1
            exit
        }

        END {
            if (__found) {
                # Print the value as is, including quotes for multi-line
                print __value
            }
        }
    ' "$__env_file")

    printf "%s" "$__value"
}


__update_value_in_env() {
# Call as __update_value_in_env "$__var" "$__value" "$__env_file"
    local __var_name="$1"
    local __new_value="$2"
    local __env_file="$3"

    # Escape backslashes for safety
    local __escaped_value
    __escaped_value=$(printf '%s' "${__new_value}" | sed 's/\\/\\\\/g')

    # Check if the variable already exists in the .env file
    if grep -q "^[ \t]*${__var_name}=" "${__env_file}"; then
        # Variable exists, update it
        awk -v var="${__var_name}" -v new_value="${__escaped_value}" '
            BEGIN { in_block = 0; multi_line = 0 }

            # Match the line that starts with the variable name
            $0 ~ "^[ \t]*" var "=" {
                # If the value starts with a quote, it may be a multi-line
                if ($0 ~ "^[ \t]*" var "=\"") {
                    # Start of multi-line value
                    multi_line = 1
                    # Print the variable name with the new value, replacing & safely
                    gsub(/&/, "\\&", new_value)
                    print var "=" new_value
                } else {
                    # Single-line value
                    gsub(/&/, "\\&", new_value)
                    print var "=" new_value
                }
                # Set the flag to indicate we are processing the target variable block
                in_block = 1
                next
            }

            # If we encounter a new variable definition, stop skipping lines
            /^[A-Z_][A-Z0-9_]*=/ && in_block {
                in_block = 0
                multi_line = 0
            }
            # Continue to skip lines in a multi-line block if multi_line is true
            multi_line && !/"[ \t]*$/ {
                next
            }

            # If we reach the end of a multi-line value, reset flags
            multi_line && /"[ \t]*$/ {
                in_block = 0
                multi_line = 0
                next
            }

            # Print all lines if not in the target variable block
            { print }
        ' "${__env_file}" | ${__as_owner} tee "${__env_file}.tmp" >/dev/null
        ${__as_owner} mv "${__env_file}.tmp" "${__env_file}"
    else
        # Variable does not exist, append it
        printf "%s=%s\n" "${__var_name}" "${__escaped_value}" | ${__as_owner} tee -a "${__env_file}" >/dev/null
    fi
}


__determine_distro() {
  # Determine OS platform
  __uname=$(uname | tr "[:upper:]" "[:lower:]")
  # If Linux, try to determine specific distribution
  if [ "$__uname" == "linux" ]; then
    # If available, use LSB to identify distribution
    if [ -n "$(which lsb_release 2>/dev/null)" ]; then
      __distro=$(lsb_release -i | cut -d: -f2 | sed s/'^\t'//)
    # Otherwise, use release info file
    else
      __distro=$(find /etc -maxdepth 1 -type f -name '[A-Za-z]*[_-][rv]e[lr]*' | grep -v "lsb" | cut -d'/' -f3 | cut -d'-' -f1 | cut -d'_' -f1)
    fi
  else
    __distro=""
  fi
  # For everything else (or if above failed), just use generic identifier
  [ "$__distro" == "" ] && __distro=$__uname
  unset __uname
  __distro=$(echo "$__distro" | tr "[:upper:]" "[:lower:]")

  if [[ "$__distro" = "ubuntu" ]]; then
    if [ "$__cannot_sudo" -eq 0 ]; then
      if ! dpkg-query -W -f='${Status}' lsb-release 2>/dev/null | grep -q "ok installed"; then
        ${__auto_sudo} apt-get update && ${__auto_sudo} apt-get -y install lsb-release
      fi
    fi
    if [ -n "$(command -v lsb_release 2>/dev/null)" ]; then
      __os_major_version=$(lsb_release -r | cut -d: -f2 | sed s/'^\t'// | cut -d. -f1)
    else
      __os_major_version=24 # Without sudo and lsb_release let's just skip the check
    fi
  elif [[ "$__distro" =~ "debian" ]]; then
    if [ "$__cannot_sudo" -eq 0 ]; then
      if ! dpkg-query -W -f='${Status}' lsb-release 2>/dev/null | grep -q "ok installed"; then
        ${__auto_sudo} apt-get update && ${__auto_sudo} apt-get -y install lsb-release
      fi
    fi
    if [ -n "$(command -v lsb_release 2>/dev/null)" ]; then
      __os_major_version=$(lsb_release -r | cut -f2)
    else
      __os_major_version=12 # Without sudo and lsb_release let's just skip the check
    fi
  fi
}


__handle_docker_sudo() {
  if [[ "$__distro" =~ "debian" || "$__distro" = "ubuntu" ]] && ! grep -qi microsoft /proc/version; then
    systemctl status docker >/dev/null
    __result=$?
    if [ ! "${__result}" -eq 0 ]; then
      echo "The Docker daemon is not running. Please check Docker installation."
      echo "\"sudo systemctl status docker\" and \"sudo journalctl -fu docker\" will be helpful."
      echo "Aborting."
      exit 1
    fi
  fi

  __docker_version=$(docker --version | awk '{ gsub(/,/, "", $3); print $3 }')
  __docker_major_version=$(docker --version | awk '{ split($3, version, "."); print version[1]; }')
  if [ "${__docker_major_version}" -lt 23 ]; then
    __old_docker=1
    echo "Docker ${__docker_version} detected"
  else
    __old_docker=0
  fi

  __docker_sudo=""
  if ! docker images >/dev/null 2>&1; then
    if [ "$__cannot_sudo" -eq 1 ]; then
      echo "Cannot call Docker and cannot use sudo. Please make your user part of the docker group"
      exit 1
    fi
    echo "Will use sudo to access Docker"
    __docker_sudo="sudo"
  fi
}


__handle_root() {
  __cannot_sudo=0
  if [ "${EUID}" -eq 0 ]; then
    __as_owner="sudo -u ${OWNER}"
    __auto_sudo=""
  else
    __as_owner=""
    if groups | grep -q '\bsudo\b' || groups | grep -q '\badmin\b'; then
      __auto_sudo="sudo"
    else
      __auto_sudo=""
      __cannot_sudo=1
    fi
  fi
}


__check_compose_version() {
# Check for Compose V2 (docker compose) vs Compose V1 (docker-compose)
  if docker compose version >/dev/null 2>&1; then
    __old_compose=0
  else
    __old_compose=1
    __compose_version=$($__docker_sudo docker-compose --version | sed -n -E -e "s/.*version [v]?([0-9.-]*).*/\1/ip")
    if [ -n "${ETHDSECUNDO-}" ]  || [ ! "${__command}" = "update" ]; then # Don't run this twice
      echo
      echo "You are using docker-compose ${__compose_version}, which is unsupported by Docker, Inc."
      echo "${__project_name} only supports Compose V2."
      echo
      echo "It is recommended that you replace Compose V1 with Compose V2."
      while true; do
        read -rp "Do you want to update Docker Compose to V2? (yes/no) " __yn
        case $__yn in
          [Nn]* ) echo "Please be sure to update Docker Compose yourself!"; break;;
           * ) __upgrade_compose; break;;
        esac
      done
    fi
  fi
}


__upgrade_compose() {
  if ! type -P docker-compose >/dev/null 2>&1; then
    echo "Docker Compose has already been updated to V2"
    return
  fi
  echo "Updating Docker Compose to V2"
  if [[ "$__distro" = "ubuntu" ]]; then
    if [ "${__os_major_version}" -lt 22 ]; then
      echo "${__project_name} cannot update Docker Compose on Ubuntu ${__os_major_version}."
      echo "Consider upgrading to 22.04 and then 24.04."
      exit 1
    fi
    if dpkg-query -W -f='${Status}' docker.io 2>/dev/null | grep -q "ok installed"; then
      ${__auto_sudo} apt-mark manual docker.io
    elif dpkg-query -W -f='${Status}' docker-ce 2>/dev/null | grep -q "ok installed"; then
      ${__auto_sudo} apt-mark manual docker-ce
    fi
    ${__auto_sudo} apt-get remove -y docker-compose
    echo "Removed docker-compose"
    ${__auto_sudo} apt-get update
    ${__auto_sudo} apt-get install -y docker-compose-v2 docker-buildx
    echo "Installed docker-compose-v2"
    __old_compose=0
    __compose_upgraded=1
  elif [[ "$__distro" =~ "debian" ]]; then
    ${__auto_sudo} apt-get update && ${__auto_sudo} apt-get -y install ca-certificates curl gnupg
    if [ "${__os_major_version}" -lt 11 ]; then
      echo "${__project_name} cannot update Docker Compose on Debian ${__os_major_version}."
      echo "Consider upgrading to 11 and then 12."
      exit 1
    fi
    if dpkg-query -W -f='${Status}' docker.io 2>/dev/null | grep -q "ok installed"; then
      ${__auto_sudo} apt-mark manual docker.io
    elif dpkg-query -W -f='${Status}' docker-ce 2>/dev/null | grep -q "ok installed"; then
      ${__auto_sudo} apt-mark manual docker-ce
    fi
    ${__auto_sudo} apt-get remove -y docker-compose
    echo "Removed docker-compose"
    ${__auto_sudo} mkdir -p /etc/apt/keyrings
    ${__auto_sudo} curl -fsSL https://download.docker.com/linux/debian/gpg | ${__auto_sudo} gpg --dearmor --yes -o /etc/apt/keyrings/docker.gpg
    ${__auto_sudo} echo \
      "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
      $(lsb_release -cs) stable" | ${__auto_sudo} tee /etc/apt/sources.list.d/docker.list > /dev/null
    ${__auto_sudo} apt-get update
    ${__auto_sudo} apt-get install -y docker-compose-plugin docker-buildx-plugin
    echo "Installed docker-compose-plugin"
    __old_compose=0
    __compose_upgraded=1
  else
    echo "${__project_name} does not know how to update Docker Compose on $__distro"
  fi
}


__check_for_snap() {
  if [[ "$__distro" = "ubuntu" && -n "$(which snap)" ]] && snap list 2>/dev/null | grep -qw 'docker'; then
    echo
    echo "WARNING! Snap Docker package detected. This WILL result in issues."
    echo "Removing the package will delete volumes and require a resync."
    echo
    echo "Doing so is still highly recommended however."
    echo
    echo "The exact steps depend a little on whether there already is an apt version of Docker installed as well,"
    echo "but in a nutshell \"$__me stop\" followed by \"sudo snap remove --purge docker\" followed by a reboot,"
    echo "and as needed install docker-ce or docker.io with apt."
    echo
    echo "Do join us on CryptoManufaktur Discord to work through this issue."
    echo
    echo "Aborting, this is not safe"
    exit 1
  fi
}


install() {
  if [ "$__cannot_sudo" -eq 1 ]; then
    echo "The install command requires the user to be part of the sudo group, or on macOS the admin group"
    exit 1
  fi

  while true; do
    read -rp "This will attempt to install Docker and make your user part of the docker group. Do you wish to continue? (no/yes) " __yn
    case $__yn in
      [Yy]* ) break;;
      * ) echo "Aborting, no changes made"; exit 130;;
    esac
  done
  if [[ "$__distro" = "ubuntu" ]]; then
    if [ "${__os_major_version}" -lt 22 ]; then
      echo "${__project_name} cannot install Docker on Ubuntu ${__os_major_version}."
      echo "Consider upgrading to 22.04 and then 24.04."
      exit 1
    fi
    if [ -z "$(which docker)" ]; then
      ${__auto_sudo} apt-get update && ${__auto_sudo} apt-get install -y ca-certificates curl gnupg \
        chrony pkg-config
      ${__auto_sudo} mkdir -p /etc/apt/keyrings
      ${__auto_sudo} curl -fsSL https://download.docker.com/linux/ubuntu/gpg | ${__auto_sudo} gpg --dearmor -o /etc/apt/keyrings/docker.gpg
      ${__auto_sudo} echo \
        "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
        $(lsb_release -cs) stable" | ${__auto_sudo} tee /etc/apt/sources.list.d/docker.list > /dev/null
      ${__auto_sudo} apt-get update
      ${__auto_sudo} apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin \
        docker-buildx-plugin
      echo "Installed docker-ce and docker-compose-plugin"
    else
      echo "Docker is already installed"
    fi
    __groups=$(${__as_owner} groups)
    if [[ ! "$__groups" =~ "docker" ]]; then
      echo "Making your user part of the docker group"
      ${__auto_sudo} usermod -aG docker "${OWNER}"
      echo "Please run newgrp docker or log out and back in"
    else
      echo "Your user is already part of the docker group"
    fi
  elif [[ "$__distro" =~ "debian" ]]; then
    if [ -z "$(which docker)" ]; then
      ${__auto_sudo} apt-get update
      ${__auto_sudo} apt-get -y install ca-certificates curl gnupg chrony pkg-config
      if [ "${__os_major_version}" -lt 11 ]; then
        echo "${__project_name} cannot install Docker on Debian ${__os_major_version}."
        echo "Consider upgrading to 11 and then 12."
        exit 1
      fi
      ${__auto_sudo} mkdir -p /etc/apt/keyrings
      ${__auto_sudo} curl -fsSL https://download.docker.com/linux/debian/gpg | ${__auto_sudo} gpg --dearmor -o /etc/apt/keyrings/docker.gpg
      ${__auto_sudo} echo \
        "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
        $(lsb_release -cs) stable" | ${__auto_sudo} tee /etc/apt/sources.list.d/docker.list > /dev/null
      ${__auto_sudo} apt-get update
      ${__auto_sudo} apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin \
        docker-buildx-plugin
      echo "Installed docker-ce and docker-compose-plugin"
    else
      echo "Docker is already installed"
    fi
    __groups=$(${__as_owner} groups)
    if [[ ! "$__groups" =~ "docker" ]]; then
      echo "Making your user part of the docker group"
      ${__auto_sudo} usermod -aG docker "${OWNER}"
      echo "Please run newgrp docker or log out and back in"
    else
      echo "Your user is already part of the docker group"
    fi
  else
    echo "${__project_name} does not know how to install Docker on $__distro"
    exit 1
  fi
  return 0
}


__get_docker_free_space() { # set __free_space to what's available to Docker
  if [[ "$OSTYPE" == "darwin"* ]]; then # macOS doesn't expose docker root dir to the OS
    __free_space=$(__dodocker run --rm -v macos-space-check:/dummy busybox df -P /dummy | awk '/[0-9]%/{print $(NF-2)}')
  else
    __docker_dir=$(__dodocker system info --format '{{.DockerRootDir}}')
    __free_space=$(df -P "${__docker_dir}" | awk '/[0-9]%/{print $(NF-2)}')
  fi

  __regex='^[0-9]+$'
  if ! [[ "${__free_space}" =~ $__regex ]] ; then
    echo "Unable to determine free disk space. This is likely a bug."
    if [[ "$OSTYPE" == "darwin"* ]]; then
      echo "df reports $(__dodocker run --rm -v macos-space-check:/dummy busybox df -P /dummy) and __free_space is ${__free_space}"
    else
      echo "df reports $(df -P "${__docker_dir}") and __free_space is ${__free_space}"
    fi
    exit 70
  fi
}


__display_docker_dir() {
  if [[ "$OSTYPE" == "darwin"* ]]; then # macOS doesn't expose docker root dir to the OS
    echo "Here's total and used space on Docker's virtual volume"
    __dodocker run --rm -v macos-space-check:/dummy busybox df -h /dummy
  else
    echo "Here's total and used space on ${__docker_dir}"
    df -h "${__docker_dir}"
  fi
}


__display_docker_volumes() {
  echo
  if [ -z "$(__dodocker volume ls -q -f "name=^$(basename "$(realpath .)")_[^_]+")" ]; then
    echo "There are no Docker volumes for this copy of ${__project_name}"
    echo
  else
    echo "Here are the Docker volumes used by this copy of ${__project_name} and their space usage:"
    __dodocker system df -v | grep -A 50 "VOLUME NAME" | grep "^$(basename "$(dirname "$(realpath "${BASH_SOURCE[0]}")")")"
    echo
  fi
  echo "If there is some mystery space being taken up, try \"sudo ncdu /\"."
  echo
}


space() {
  __get_docker_free_space
  echo
  if [[ "$OSTYPE" == "darwin"* ]]; then # macOS doesn't expose docker root dir to the OS
    echo "You have $(( __free_space / 1024 / 1024 )) GiB free for Docker volumes"
  else
    echo "You have $(( __free_space / 1024 / 1024 )) GiB free on ${__docker_dir}"
  fi
  echo
  __display_docker_dir
  __display_docker_volumes
}


# Warn user if space is low, so they can prune
__check_disk_space() {
  __get_docker_free_space

  if [[ "${__free_space}" -lt 52428800 ]]; then
    echo
    echo "You have less than 50 GiB of free disk space:"
    echo
    __display_docker_dir
    echo
    echo "Pruning does not appear an option for your client mix."
    echo "If total space is less than 1.8 TiB, consider cloning to a larger drive."
    __display_docker_volumes
  fi
}


__nag_os_version() {
  if [[ "$__distro" = "ubuntu" ]]; then
    if [ "${__os_major_version}" -lt 22 ]; then
      echo
      echo "Ubuntu ${__os_major_version} is older than the recommended 24.04 or 22.04 version."
      echo
      echo "Updating is neither urgent nor required, merely recommended."
    fi
  elif [[ "$__distro" =~ "debian" ]]; then
    if [ "${__os_major_version}" -lt 11 ]; then
      echo
      echo "Debian ${__os_major_version} is older than the recommended 12 or 11 version."
      echo
      echo "Updating is neither urgent nor required, merely recommended."
    fi
  fi
}


__pull_and_build() {
  __dodocker system prune --force
  __docompose --profile tools pull
  __docompose --profile tools build --pull
}


# Arguments are passed, but shellcheck doesn't recognize that
# shellcheck disable=SC2120
update() {
  __during_update=1
  if [[ $(${__as_owner} git status --porcelain) ]]; then
    __dirty=1
  else
    __dirty=0
  fi

  __free_space=$(df -P "$(pwd)" | awk '/[0-9]%/{print $(NF-2)}')

  __regex='^[0-9]+$'
  if ! [[ "${__free_space}" =~ $__regex ]] ; then
    echo "Unable to determine free disk space. This is likely a bug."
    echo "df reports $(df -P "$(pwd)") and __free_space is ${__free_space}"
    exit 70
  elif [ "$(df -P "$(pwd)" | awk '/[0-9]%/{print $(NF-2)}')" -lt 1024 ]; then
    echo "You have less than 1 MiB of space left on $(pwd)."
    echo "Aborting, as an update is not safe."
    exit 1
  fi

  __get_docker_free_space
  if [ "${__free_space}" -lt 1048576 ]; then
    echo "You have less than 1 GiB of space left for Docker volumes."
    echo "Aborting, as an update is not safe."
    exit 1
  fi

  if [ -z "${ETHDSECUNDO-}" ]; then
    set +e
    ${__as_owner} git config pull.rebase false
    __var="SCRIPT_TAG"
    __value=$(__get_value_from_env "${__var}" "${__env_file}")
    if [ -z "${__value}" ] || [ "${__value}" = "latest" ]; then
      export ETHDPINNED=""
      __branch=$(git rev-parse --abbrev-ref HEAD)
      if [[ "${__branch}" =~ ^tag-* ]]; then
        git checkout main
      fi
      ${__as_owner} git pull
    else
      export ETHDPINNED="${__value}"
      ${__as_owner} git fetch --tags
      ${__as_owner} git checkout -B "tag-${__value}" "tags/${__value}"
    fi
    export GITEXITCODE=$?
    set -e
    # BASH_SOURCE so newer code gets to do the update. Use an ENV var
    # to avoid infinite loop
    export ETHDSECUNDO=1
    exec "${BASH_SOURCE[0]}" update "$@"
  fi

  __env_migrate
  __pull_and_build

  if [ "${__migrated}" -eq 1 ] && ! cmp -s "${__env_file}" "${__env_file}".source; then
    cp "${__env_file}".source "${__env_file}".bak
    rm "${__env_file}".source
    echo "Your ${__env_file} configuration settings have been migrated to a fresh copy. You can \
find the original contents in ${__env_file}.bak."
    echo
    echo "List of changes made to ${__env_file} during migration - current on left, original on right:"
    echo
    diff -y --suppress-common-lines "${__env_file}" "${__env_file}".bak || true
  else
    echo "No changes made to ${__env_file} during update"
    if [ -f "${__env_file}".source ]; then
      ${__as_owner} rm "${__env_file}".source || true
    fi
  fi
  echo
  if [ -z "${GITEXITCODE+x}" ] || [ "${GITEXITCODE}" -eq 0 ]; then
    echo "A \"$__me up\" command will start using the new images and configuration."
  else
    echo "WARNING"
    echo
    echo "Updating ${__project_name} failed during \"git pull\""
    echo
    echo "Please try \"git pull\" manually."
    echo "Do not run \"$__me up\" until git can update ${__project_name}."
    echo "The current partial update risks startup failure."
  fi

  __nag_os_version

  unset ETHDSECUNDO
  unset GITEXITCODE
  if [ "${__dirty}" -eq 1 ]; then
    echo
    echo "WARNING"
    echo
    echo "You have uncommitted local changes to ${__project_name}, which may interfere with updates."
    echo "Please undo these changes or \"git commit\" them."
    echo "These are the files with local changes:"
    echo
    ${__as_owner} git status --porcelain
  fi
  if [ -n "${ETHDPINNED:-}" ]; then
    echo "${__project_name} version is pinned to ${ETHDPINNED} in \".env\"."
    echo "Please make sure to run compatible client versions."
  fi
  __during_update=0
}


upgrade() {
  update
}


start() {
  __docompose up -d --remove-orphans "$@"
}


up() {
  start "$@"
}


run() {
  start "$@"
}


stop() {
  __docompose down --remove-orphans "$@"
}


# Passed by user
# shellcheck disable=SC2120
down() {
  stop "$@"
}


restart() {
  stop "$@"
  start "$@"
}


logs() {
  __docompose logs "$@"
}


cmd() {
  __docompose "$@"
}


terminate() {
  if [ -z "$(__dodocker volume ls -q -f "name=^$(basename "$(realpath .)")_.+")" ]; then
    echo "There are no data stores - Docker volumes - left to remove for this ${__app_name}."
    stop
    exit 0
  fi

  while true; do
    read -rp "WARNING - this action will destroy all data stores for this ${__app_name}. Do you wish to continue? (No/Yes) " __yn
    case $__yn in
      [Yy]es ) break;;
      * ) echo "Aborting, no changes made"; exit 130;;
    esac
  done

  down
# In this case I want the word splitting, so rm can remove all volumes
# shellcheck disable=SC2046
  __dodocker volume rm $(__dodocker volume ls -q -f "name=^$(basename "$(realpath .)")_.+")
  echo
  echo "All containers stopped and all volumes deleted"
  echo
}


__handle_error() {
  if [[ ! $- =~ e ]]; then
# set +e, do nothing
    return 0
  fi

  local __exit_code=$1
  local __line_no=$2
  if [ "$__exit_code" -eq 130 ]; then
    echo "$__me terminated by user"
  else
    echo "$__me terminated with exit code $__exit_code on line $__line_no"
    if [ -n "${__command}" ]; then
      echo "This happened during $__me ${__command} ${__params}"
    fi
  fi
  if [ "$__during_update" -eq 1 ] && [ "$__during_migrate" -eq 1 ]; then
    cp "${__env_file}" "${__env_file}".partial
    cp "${__env_file}".source "${__env_file}"
    echo
    echo "Restored your ${__env_file} file, to undo partial migration. Please verify it looks correct."
    echo "The partially migrated file is in ${__env_file}.partial for troubleshooting."
  fi
}


help() {
  echo "usage: ${__me} [-h|--help] <command>"
  echo
  echo "commands:"
  echo "  install"
  echo "    attempts to install Docker and Docker Compose for you"
  echo "  update "
  echo "    updates all client versions and ${__project_name} itself"
  echo "  up|start [service-name]"
  echo "    starts the ${__app_name}, or restarts containers that had their image or"
  echo "    configuration changed. Can also start a specific service by name"
  echo "  down|stop [service-name]"
  echo "    stops the ${__app_name}, or a specific service by name"
  echo "  restart [service-name]"
  echo "    restarts the ${__app_name}, or a specific service by name, a combination of down and up"
  echo "  version"
  echo "    prints the version(s) of currently running client(s)"
  echo "  logs"
  echo "    shows logs"
  echo "  cmd <command>"
  echo "    executes an arbitrary Docker Compose command. Use \"cmd help\" to list them"
  echo "  terminate"
  echo "    stops the ${__app_name} and destroys all data stores"
  echo "  space"
  echo "    show Docker volume space usage"
  echo "  help"
  echo "    print this help screen"
  echo
  echo "The logs command can be appended by flags and specify the container(s). example: "
  echo
  echo "  $__me logs -f --tail 50 ${__sample_service}"
  echo "    shows logs only for ${__sample_service} service"
  echo
  echo "$__me will attempt to use sudo as needed for Docker commands"
  echo
}


# Main body from here
__env_file=.env
__during_update=0
__during_migrate=0
__migrated=0
__command=""
__me="./$(basename "${BASH_SOURCE[0]}")"

trap '__handle_error $? $LINENO' ERR

if [[ "$#" -eq 0 || "$1" == "-h" || "$1" == "--help" ]]; then
  help
  exit 0
fi

cd "$(dirname "$(realpath "${BASH_SOURCE[0]}")")"
# Use this to make sure root doesn't end up owning files
# shellcheck disable=SC2012
OWNER=$(ls -ld . | awk '{print $3}')

if [ "${OWNER}" == "root" ]; then
  echo "Please install ${__project_name} as a non-root user."
  exit 0
fi

__command="$1"
shift
__params=$*

__handle_root
__determine_distro
__prep_conffiles

__check_for_snap

if [ "$__command" = "install" ]; then
  $__command "$@"
  exit "$?"
fi

__handle_docker_sudo
__check_compose_version

if [ "${__old_compose}" -eq 1 ]; then
  echo
  echo "You are using docker-compose ${__compose_version}, which is unsupported by Docker, Inc."
  echo "${__project_name} only supports Compose V2."
  echo
  echo "You can install it with \"sudo apt update && sudo apt install docker-compose-v2\"."
  echo "You can remove the old docker-compose:"
  echo "\"sudo apt-mark manual docker.io && sudo apt --autoremove remove docker-compose\"."
  exit 0
fi

if [ "${__old_docker}" -eq 1 ]; then
  echo
  echo "Docker version ${__docker_version} detected. This version is no longer supported."
  echo "Please update to a current version. Supported versions can be seen at https://endoflife.date/docker-engine."
  echo
  echo "This should be as simple as \"sudo apt update && sudo apt dist-upgrade\" on Debian/Ubuntu"
  echo "or updating Docker Desktop on macOS and Windows."
  exit 0
fi

if ! __dodocker images >/dev/null 2>&1; then
  echo "Please ensure you can call $__docker_exe before running ${__me}."
  exit 1
fi

if ! __docompose --help >/dev/null 2>&1; then
  echo "Please ensure you can call $__compose_exe before running ${__me}."
  exit 1
fi

case "$__command" in
  help|update|up|start|down|stop|restart|version|logs|cmd|terminate|space)
    $__command "$@";;
  *)
    echo "Unrecognized command $__command"
    help
    ;;
esac

__check_disk_space

if [ "${__compose_upgraded}" -eq 1 ]; then
  echo
  echo "You updated Docker Compose to V2."
  echo "The \"docker-compose\" command is gone and replaced with \"docker compose\"."
  echo
  echo "You can create an alias for \"docker-compose\" by adding this line to your \"~/.profile\":"
  echo "alias docker-compose=\"docker compose\""
  echo
  echo "Optionally, you can switch to docker-ce."
  echo "Please see https://ethdocker.com/Usage/Prerequisites#switching-from-dockerio-to-docker-ce for instructions."
fi