ethd

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

__project_name="Optimism Docker"
__app_name="OP Stack node"
__sample_service="op-geth"
__docker_exe="docker"
__compose_exe="docker compose"
__compose_upgraded=0


version() {
# script version
  grep "^This is" README.md
  echo
  __var="COMPOSE_FILE"
  __get_value_from_env "${__var}" "${__env_file}" "__value"
# Client versions
  case "${__value}" in
    *optimism.yml* )
      echo "OPGETH_DOCKER_TAG: $(grep -E '^OPGETH_DOCKER_TAG=' "${__env_file}" | cut -d '=' -f2)"
      __docompose exec op-geth geth version
      echo
      echo "OPNODE_DOCKER_TAG: $(grep -E '^OPNODE_DOCKER_TAG=' "${__env_file}" | cut -d '=' -f2)"
      __docompose exec op-node op-node --version
      ;;&
  esac
}


__prep_conffiles() {
# Remove this after the next hardfork, when there's a new ext-network
# Create ext-network.yml if it doesn't exist
  if [ ! -f "ext-network.yml" ]; then
    ${__as_owner} cp ext-network.yml.sample ext-network.yml
  fi
  return
}


__warn_l1() {
  __var="L1_RPC"
  __get_value_from_env "${__var}" "${__env_file}" "__value"
# Literal match intended
# shellcheck disable=SC2076
  if [[ "${__value}" =~ "example.com" ]]; then
    echo "Warning: Your L1 RPC (EL) is not set to a valid value. Syncing will fail."
    echo
  fi
  __var="L1_BEACON"
  __get_value_from_env "${__var}" "${__env_file}" "__value"
# Literal match intended
# shellcheck disable=SC2076
  if [[ "${__value}" =~ "example.com" ]]; then
    echo "Warning: Your L1 Beacon (CL) is not set to a valid value. Syncing will fail."
    echo
  fi
}


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

  __old_vars=( EIGENDA_VERSION )
  __new_vars=( EIGENDA_DOCKER_TAG )

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

  if [ "${__debug}" -eq 1 ]; then  # Find any values in default.env that contain dashes
    __error=0
    while IFS= read -r __line; do
      # Skip blank lines and comments
      [[ -z "${__line}" || "${__line}" =~ ^# ]] && continue

      # Warn on dash-containing variable names
      if [[ "${__line}" =~ ^([A-Za-z0-9_-]+)= ]]; then
        __varname="${BASH_REMATCH[1]}"
        if [[ "${__varname}" = *-* ]]; then
          echo "❌ Error: Variable '${__varname}' contains a dash and would not be usable in Bash."
          (( ++__error ))
        fi
        if [[ "${__varname}" = "ENV_VERSION" ]]; then
          continue
        fi
      else
        continue  # Doesn't match variable assignment format
      fi
    done < "./default.env"
    if [ "${__error}" -gt 0 ]; then
      exit 1
    fi
  fi

#shellcheck disable=SC2154
  if [[ "${__keep_targets}" -eq 1 && "${__target_ver}" -le "${__source_ver}" ]]; then # No changes in template, do nothing
    return 0
  fi

  if [ "${__keep_targets}" -eq 0 ]; then
    echo "Refreshing build targets in ${__env_file}"
  fi
  if [[ "${__target_ver}" -gt "${__source_ver}" ]]; then
    echo "Migrating ${__env_file} to version ${__target_ver}"
  fi

  ${__as_owner} cp "${__env_file}" "${__env_file}".source
  __during_migrate=1
  __migrated=1
  ${__as_owner} cp default.env "${__env_file}"

  # Migrate over user settings
  while IFS= read -r __line; do  # read default.env and process all variables in it
    # Skip blank lines and comments
    [[ -z "${__line}" || "${__line}" =~ ^# ]] && continue

    if [[ "${__line}" =~ ^([A-Za-z0-9_-]+)= ]]; then
      __var="${BASH_REMATCH[1]}"
    else
      continue  # Doesn't match variable assignment format
    fi
    if [[ "${__var}" = "ENV_VERSION" ]]; then
      continue
    fi

    __get_value_from_env "${__var}" "${__env_file}.source" "__value"
    if [ "${__found}" -eq 1 ]; then  # Only if variable isn't new in default.env
      if [[ "${__keep_targets}" -eq 0 && "$__var" =~ (_TAG|_REPO|_DOCKERFILE)$ ]]; then
        __get_value_from_env "${__var}" "default.env" "__value" # Reset build target to default.env value
      fi
      # Handle & gracefully, as well as multi-line
      __update_value_in_env "${__var}" "$__value" "${__env_file}"
    fi
  done < "./default.env"

  # Move value from old variable name(s) to new one(s)
  for __index in "${!__old_vars[@]}"; do
    __var=${__old_vars[__index]}
    __get_value_from_env "${__var}" "${__env_file}.source" "__value"
    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() {
  # Call with variable name to read, env file name, and global variable to assign the value to
  # Also sets global __found
  local __var_name="$1"
  local __env_file="$2"
  local __output_var="$3"
  local __output
  local __parsed_value

  if [[ "${__output_var}" == "__parsed_value" || "${__output_var}" == "__output_var" \
      || "${__output_var}" == "__output" || "${__output_var}" == "__env_file" \
      || "${__output_var}" == "__var_name" ]]; then
    echo "❌ __get_value_from_env was called with a conflicting output variable: $__output_var" >&2
    echo "This is a bug."  >&2
    exit 1
  fi

  __output=$(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 empty unquoted value
    $0 ~ "^[ \t]*"var"=$" {
       __value = ""
       __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 {
      # Print here-doc style so we can parse with awk
      # Print the value as is, including quotes for multi-line
      print "__value<<EOF"
      print __value
      print "EOF"
      print "__found=" __found
    }
  ' "$__env_file")

  # Parse __value using here-doc style
  __parsed_value=$(awk '/^__value<<EOF$/ {getline; while ($0 != "EOF") { print; getline } }' <<< "$__output")
  # Parse __found directly into a global variable
  __found=$(awk -F= '/^__found=/ {print $2}' <<< "$__output")

  # assign value to caller’s variable
  printf -v "$__output_var" '%s' "$__parsed_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 500 "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() {
# Only one copy of update() should run per stack
  local __script_dir
  __script_dir="$(dirname "$(realpath "${BASH_SOURCE[0]}")")"
  local __uniq_id="${__script_dir//\//_}"
  local __lock_file="${__uniq_id}_lock"
  ${__as_owner} touch "/tmp/${__lock_file}"
  exec 200<"/tmp/${__lock_file}"
  if ! flock -n 200; then
    echo "Another instance of \"${__me} update\" is running. Aborting."
    exit 1
  fi

  __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"
    __get_value_from_env "${__var}" "${__env_file}" "__value"
    if [ -z "${__value}" ] || [ "${__value}" = "latest" ]; then
      export ETHDPINNED=""
      __branch=$(git rev-parse --abbrev-ref HEAD)
      if [[ "${__branch}" =~ ^tag-* ]]; then
        git checkout main
      fi
# Handle legacy ext-network. A future update after a hardfork will bring in the changed ext-network
      DOCKER_EXT_NETWORK=$(${__as_owner} sed -n 's/^\s*name:\s*\(.*\)/\1/p' ext-network.yml)
# I mean this literally
# shellcheck disable=SC2016
      if [ ! "${DOCKER_EXT_NETWORK:-"traefik_default"}" = '${DOCKER_EXT_NETWORK}' ]; then
        __var=DOCKER_EXT_NETWORK
        __update_value_in_env "${__var}" "${!__var}" "${__env_file}"
        ${__as_owner} cp ext-network.yml ext-network.yml.bak
        ${__as_owner} rm -f ext-network.yml
      fi
# End legacy handling
      ${__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

# Remove this after the next hardfork
  if [ -f "ext-network.yml.bak" ]; then
    ${__as_owner} cp ext-network.yml.bak ext-network.yml
    ${__as_owner} rm ext-network.yml.bak
  fi

  __keep_targets=1
  __debug=0
  while :
  do
    if [ -z "${1+x}" ]; then
      break
    fi
    case "$1" in
      --refresh-targets | --reset-targets)
        __keep_targets=0
        shift
        ;;
      --non-interactive)
        __non_interactive=1
        shift
        ;;
      --debug)
        __debug=1
        shift
        ;;
      *)
        echo "Error: Unknown option: $1" >&2
        shift
        ;;
    esac
  done
  if [ "${ETHD_FRONTEND:-}" = "noninteractive" ]; then
    __non_interactive=1
  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
  __warn_l1
# Release lock and remove lock file
  exec 200<&-
  ${__as_owner} rm -f "/tmp/${__lock_file}"
  __during_update=0
}


upgrade() {
  update
}


start() {
  if ! type -P screen >/dev/null 2>&1; then
    ${__auto_sudo} apt-get update && ${__auto_sudo} apt-get install -y screen
  fi
  __var="NETWORK"
  __get_value_from_env "${__var}" "${__env_file}" "__screen_id"
# shellcheck disable=SC2154
  rm -f "/tmp/${__screen_id}-compose-screen.log"
# shellcheck disable=SC2086
  screen -dmS "${__screen_id}-compose-session" -L -Logfile "/tmp/${__screen_id}-compose-screen.log" ${__compose_exe} up -d --remove-orphans "$@"
  echo "Running \"docker compose up -d\" in screen because of the init container."
  echo
  echo "If this is your first start and you are getting a SNAPSHOT, you can view the init logs:"
  echo "\"${__me} logs -f op-geth-init\""
  echo
  echo "You can attach to the screen session with \"screen -r ${__screen_id}-compose-session\""
  echo
  echo "Waiting 5 seconds"
  sleep 5
  echo
  echo "Here's the output of docker compose so far:"
  cat "/tmp/${__screen_id}-compose-screen.log"
  echo
}


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
}


__update_help() {
  echo "usage: $__me update [--refresh-targets] [--non-interactive] [--debug]"
  echo
  echo "Updates Eth Docker itself, as required the contents of \".env\", and the clients."
  echo
  echo "A combination of \"git pull\" for Eth Docker, some bash scripting to bring new variables from \"default.env\","
  echo "and \"docker compose pull\" as well as \"docker compose build\" for the clients."
  echo
  echo "If warranted, will also offer resync when clients require it, or upgrade of PostgreSQL version."
  echo
  echo "\"--refresh-targets\" sets Docker tags, source targets, and repos of clients back to the defaults in \"default.env\"."
  echo "\"--non-interactive\" does not ask questions and assumes Yes for database resyncs and migrations."
  echo "\"--debug\" handles some CI sanity checks."
  echo
}


__full_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
}


help() {
  case $* in
    *update*) __update_help;;
    *) __full_help;;
  esac
}


# 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 || "$*" =~ "-h" ]]; then # Lazy match for -h and --help but also --histogram, so careful here
  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