start

#! /usr/bin/env bash
set -e

clear=$(echo -e "\e[0m")
green=$(echo -e "\e[32m")
blue=$(echo -e "\e[34m")
purple=$(echo -e "\e[35m")
cyan=$(echo -e "\e[36m")

export STELLAR_HOME="/opt/stellar"
export PGHOME="$STELLAR_HOME/postgresql"
export SUPHOME="$STELLAR_HOME/supervisor"
export COREHOME="$STELLAR_HOME/core"
export HZHOME="$STELLAR_HOME/horizon"
export FBHOME="$STELLAR_HOME/friendbot"
export LABHOME="$STELLAR_HOME/lab"
export NXHOME="$STELLAR_HOME/nginx"
export STELLAR_RPC_HOME="$STELLAR_HOME/stellar-rpc"
export GALEXIEHOME="$STELLAR_HOME/galexie"
export LEDGERMETASTOREHOME="$STELLAR_HOME/ledger-meta-store"
export HISTORYARCHIVEHOME="$STELLAR_HOME/history-archive"

export CORELOG="/var/log/stellar-core"

export PGBIN="/usr/lib/postgresql/14/bin/"
export PGDATA="$PGHOME/data"
export PGUSER="stellar"
export PGPORT=5432

export PROTOCOL_VERSION_DEFAULT="$(< /image.json jq -r '.config.protocol_version_default')"

: "${PROTOCOL_VERSION:=$PROTOCOL_VERSION_DEFAULT}"
: "${ENABLE:=core,horizon,rpc}"
: "${ENABLE_LOGS:=false}"
: "${ENABLE_CORE:=false}"
: "${ENABLE_HORIZON:=false}"
: "${ENABLE_LAB:=false}"
: "${ENABLE_GALEXIE:=false}"
# TODO: Remove once the Soroban RPC name is fully deprecated
: "${ENABLE_SOROBAN_RPC:=false}"
: "${ENABLE_RPC:=$ENABLE_SOROBAN_RPC}"
: "${ENABLE_SOROBAN_DIAGNOSTIC_EVENTS:=false}"
: "${DISABLE_SOROBAN_DIAGNOSTIC_EVENTS:=false}"
# TODO: Remove once the Soroban RPC name is fully deprecated
: "${ENABLE_SOROBAN_RPC_ADMIN_ENDPOINT:=false}"
: "${ENABLE_RPC_ADMIN_ENDPOINT:=$ENABLE_SOROBAN_RPC_ADMIN_ENDPOINT}"
: "${ENABLE_CORE_MANUAL_CLOSE:=false}"
: "${CORE_LOG_LEVEL:=}"
: "${CORE_USE_POSTGRES:=}"
: "${LIMITS:=testnet}"

CURRENT_POSTGRES_PID=""

function main() {
  process_args $*
  validate_before_start
  start
}

function validate_before_start() {
  if [ "$ENABLE_RPC" != "true" ] && [ "$ENABLE_RPC_ADMIN_ENDPOINT" = "true" ]; then
    echo "--enable-stellar-rpc-admin-endpoint usage only supported with --enable-stellar-rpc" >&2
    exit 1
  fi
  if [ "$NETWORK" != "local" ] && [ "$RANDOMIZE_NETWORK_PASSPHRASE" = "true" ]; then
    echo "--randomize-network-passphrase is only supported in the local network" >&2
    exit 1
  fi
  if [ "$NETWORK" != "local" ] && [ "$ENABLE_GALEXIE" = "true" ]; then
    echo "--enable galexie is only supported in the local network" >&2
    exit 1
  fi
  if [ "$NETWORK" = "local" ] && [ "$DISABLE_SOROBAN_DIAGNOSTIC_EVENTS" = "false" ]; then
    ENABLE_SOROBAN_DIAGNOSTIC_EVENTS=true
  fi
}

function validate_after_copy_defaults() {
  if [ "$NETWORK" = "local" ] && [ "$LIMITS" != "default" ]; then
    local config_dir="$COREHOME/etc/config-settings/p$PROTOCOL_VERSION"
    local config_path="$config_dir/$LIMITS.json"
    if [ ! -f "$config_path" ]; then
      echo "--limits '$LIMITS' unknown: must be one of: default "$(ls $config_dir | sed 's/\.json//g')
      exit 1
    fi
  fi
}

function start() {
  echo "Starting Stellar Quickstart"

  echo "versions:"
  echo "  quickstart: $REVISION"
  echo "  xdr:"
  echo "$(stellar-xdr version | sed 's/^/    /')"
  echo "  core:"
  echo "$(stellar-core version 2>/dev/null | sed 's/^/    /')"
  echo "  rpc:"
  echo "$(stellar-rpc version | sed 's/^/    /')"
  echo "  horizon:"
  echo "$(stellar-horizon version | sed 's/^/    /')"
  echo "  friendbot:"
  echo "    $(< /image.json jq -r '.deps[] | select(.name == "friendbot") | "\(.ref) (\(.sha))"')"
  echo "  lab:"
  echo "    $(< /image.json jq -r '.deps[] | select(.name == "lab") | "\(.ref) (\(.sha))"')"
  echo "  galexie:"
  echo "    $(< /image.json jq -r '.deps[] | select(.name == "galexie") | "\(.ref) (\(.sha))"')"

  echo "mode: $STELLAR_MODE"
  echo "network: $NETWORK"
  echo "network passphrase: $NETWORK_PASSPHRASE"
  echo "network id: $NETWORK_ID"
  echo "network root secret key: $NETWORK_ROOT_SECRET_KEY"
  echo "network root account id: $NETWORK_ROOT_ACCOUNT_ID"
  echo "protocol version default: $PROTOCOL_VERSION_DEFAULT"
  echo "protocol version set: $PROTOCOL_VERSION"

  copy_defaults
  validate_after_copy_defaults
  init_db
  init_stellar_core
  init_friendbot
  init_horizon
  copy_pgpass
  init_stellar_rpc
  init_galexie

  stop_postgres  # this gets started in init_db

  # launch services
  if [ "$ENABLE_LOGS" = "true" ]; then
    print_service_logs &
    exec_supervisor \
      >  >(sed "s/^/${cyan}quickstart   | $clear/") \
      2> >(sed "s/^/${cyan}quickstart   | $clear/" >&2)
  else
    exec_supervisor
  fi
}

function process_args() {
  while [[ -n "$1" ]]; do
    ARG="$1"
    shift
    case "${ARG}" in
    --logs)
      ENABLE_LOGS=true
      ;;
    --testnet)
      NETWORK="testnet"
      ;;
    --pubnet)
      NETWORK="pubnet"
      ;;
    --local)
      NETWORK="local"
      ;;
    --standalone)
      echo "deprecated: option --standalone has been replaced by --local"
      NETWORK="local"
      ;;
    --futurenet)
      NETWORK="futurenet"
      ;;
    --protocol-version)
      export PROTOCOL_VERSION="$1"
      shift
      ;;
    --enable-asset-stats)
      export ENABLE_ASSET_STATS="$1"
      shift
      ;;
    --enable-lab)
      ENABLE_LAB=true
      ;;
    --limits)
      export LIMITS="$1"
      shift
      ;;
    --enable)
      ENABLE="$1"
      shift
      ;;
    # TODO: remove once the Soroban RPC name is fully deprecated
    --enable-soroban-rpc)
      ENABLE_RPC=true
      ;;
    --enable-soroban-diagnostic-events)
      ENABLE_SOROBAN_DIAGNOSTIC_EVENTS=true
      ;;
    --disable-soroban-diagnostic-events)
      DISABLE_SOROBAN_DIAGNOSTIC_EVENTS=true
      ;;
    --enable-stellar-rpc-admin-endpoint)
      ENABLE_RPC_ADMIN_ENDPOINT=true
      ;;
    # TODO: remove once the Soroban RPC name is fully deprecated
    --enable-soroban-rpc-admin-endpoint)
      ENABLE_RPC_ADMIN_ENDPOINT=true
      ;;
    --enable-core-manual-close)
      ENABLE_CORE_MANUAL_CLOSE=true
      ;;
    --randomize-network-passphrase)
      RANDOMIZE_NETWORK_PASSPHRASE=true
      ;;
    --core-log-level)
      CORE_LOG_LEVEL="$1"
      shift
      ;;
    *)
      echo "Unknown container arg $ARG" >&2
      exit 1
    esac
  done

  # TODO: ask for what network to use
  if [ -z "$NETWORK" ]; then
    NETWORK="testnet"
  fi

  if [[ ",$ENABLE," = *",core,"* ]]; then
    ENABLE_CORE=true
  fi

  if [[ ",$ENABLE," = *",horizon,"* ]]; then
    ENABLE_HORIZON=true
  fi

  if [[ ",$ENABLE," = *",rpc,"* ]]; then
    ENABLE_RPC=true
  fi

  if [[ ",$ENABLE," = *",lab,"* ]]; then
    ENABLE_LAB=true
  fi

  if [[ ",$ENABLE," = *",galexie,"* ]]; then
    ENABLE_GALEXIE=true
  fi

  case "$NETWORK" in
  testnet)
    export NETWORK_PASSPHRASE="Test SDF Network ; September 2015"
    export HISTORY_ARCHIVE_URLS="https://history.stellar.org/prd/core-testnet/core_testnet_001"
    ;;
  pubnet)
    export NETWORK_PASSPHRASE="Public Global Stellar Network ; September 2015"
    export HISTORY_ARCHIVE_URLS="https://history.stellar.org/prd/core-live/core_live_001"
    ;;
  local)
    if [ -z "$NETWORK_PASSPHRASE" ]; then
      export NETWORK_PASSPHRASE="Standalone Network ; February 2017"
    fi
    # h1570ry - we'll start a webserver connected to history directory later on
    export HISTORY_ARCHIVE_URLS="http://localhost:1570"
    ENABLE_CORE=true
    ;;
  futurenet)
    export NETWORK_PASSPHRASE="Test SDF Future Network ; October 2022"
    export HISTORY_ARCHIVE_URLS="http://history.stellar.org/dev/core-futurenet/core_futurenet_001"
    ;;
  *)
    echo "Unknown network: '$NETWORK'" >&2
    exit 1
  esac

  if [ "$RANDOMIZE_NETWORK_PASSPHRASE" = "true" ]; then
    NETWORK_PASSPHRASE="${NETWORK_PASSPHRASE} ; $(openssl rand -hex 32)"
  fi

  export NETWORK_ID=$(printf "$NETWORK_PASSPHRASE" | sha256sum | cut -f 1 -d " ")
  local network_id_keys=$(stellar-core convert-id $NETWORK_ID | awk -F': ' '/strKey: /{print $2}' | tail -2)
  export NETWORK_ROOT_SECRET_KEY=$(printf "$network_id_keys" | head -1)
  export NETWORK_ROOT_ACCOUNT_ID=$(printf "$network_id_keys" | tail -1)

  # Are we ephemeral or persistent?
  if [ -z "$STELLAR_MODE" ]; then
    if [ -f "/opt/stellar/.docker-ephemeral" ]; then
      STELLAR_MODE="ephemeral"
    else
      STELLAR_MODE="persistent"
    fi
  fi
}

function set_pg_password() {

  if [ -n "$POSTGRES_PASSWORD" ]; then
    PGPASS=$POSTGRES_PASSWORD
    echo "using POSTGRES_PASSWORD"
    return 0
  fi

  # use a random password when ephemeral (or some other unknown mode)
  if [ "$STELLAR_MODE" != "persistent" ]; then
    PGPASS=$(head /dev/urandom | tr -dc 'a-zA-Z0-9' |  head -c 16)
    echo "postgres password: $PGPASS"
    return 0
  fi

  if [ -n "$PGPASS" ]; then
    echo "postgres password: $PGPASS"
    return 0
  fi

  # ask for a password when persistent
  read -s -p "Enter New Postgresql Password: " PGPASS ||
    (
      echo Postgresql password not supplied. Set the POSTGRES_PASSWORD environment variable, or run the container interactively and provide the password via stdin.
      exit 1
    )
  echo ""
  read -s -p "Confirm: " PGPASS_CONFIRMATION
  echo ""

  if [ -z "$PGPASS" ]; then
    echo "Password empty" >&2
    exit 1
  fi

  if [ "$PGPASS" != "$PGPASS_CONFIRMATION" ]; then
    echo "Password mistmach" >&2
    exit 1
  fi

}

function copy_defaults() {
  local CP="rsync -a"

  if [ -d $PGHOME/etc ]; then
    echo "postgres: config directory exists, skipping copy"
  else
    $CP /opt/stellar-default/common/postgresql/ $PGHOME
  fi

  if [ -d $SUPHOME/etc ]; then
    echo "supervisor: config directory exists, skipping copy"
  else
    $CP /opt/stellar-default/common/supervisor/ $SUPHOME
    cp /opt/stellar-default/$NETWORK/supervisor/etc/supervisord.conf.d/stellar-rpc.conf $SUPHOME/etc/supervisord.conf.d 2>/dev/null || true
    cp /opt/stellar-default/$NETWORK/supervisor/etc/supervisord.conf.d/galexie.conf $SUPHOME/etc/supervisord.conf.d 2>/dev/null || true
    cp /opt/stellar-default/$NETWORK/supervisor/etc/supervisord.conf.d/ledger-meta-store.conf $SUPHOME/etc/supervisord.conf.d 2>/dev/null || true
    cp /opt/stellar-default/$NETWORK/supervisor/etc/supervisord.conf.d/friendbot.conf $SUPHOME/etc/supervisord.conf.d 2>/dev/null || true
    cp /opt/stellar-default/$NETWORK/supervisor/etc/supervisord.conf.d/history-archive.conf $SUPHOME/etc/supervisord.conf.d 2>/dev/null || true
  fi

  if [ -d $COREHOME/etc ]; then
    echo "stellar-core: config directory exists, skipping copy"
  else
    $CP /opt/stellar-default/common/core/ $COREHOME
    $CP /opt/stellar-default/$NETWORK/core/ $COREHOME
    if [ "$NETWORK" = "local" ]; then
      # If there are no config settings for the current network, use the config
      # settings from the most recent protocol.
      local config_dir_base="$COREHOME/etc/config-settings"
      local config_dir="$config_dir_base/p$PROTOCOL_VERSION"
      if [ ! -d "$config_dir" ]; then
        # Symlink the config-dir from the most recent protocol version. For
        # example, if $PROTOCOL_VERSION is 25, and there is no config settings
        # for p25, look for config settings for p24, p23, so on until the
        # directory exists. Protocol 20 is the first protocol that has
        # settings. Once the directory exists, create a symlink for p25 -> p23.
        for ((v=PROTOCOL_VERSION-1; v>=20; v--)); do
          local v_dir="p$v"
          local fallback_dir="$config_dir_base/$v_dir"
          if [ -d "$fallback_dir" ]; then
            ln -fs "$v_dir" "$config_dir"
            break
          fi
        done
      fi
    fi
  fi

  if [ -d $HZHOME/etc ]; then
    echo "horizon: config directory exists, skipping copy"
  else
    $CP /opt/stellar-default/common/horizon/ $HZHOME
    if [ -d /opt/stellar-default/$NETWORK/horizon/ ]; then
      $CP /opt/stellar-default/$NETWORK/horizon/ $HZHOME
    fi
  fi

  if [ -d $STELLAR_RPC_HOME/etc ]; then
    echo "stellar-rpc: config directory exists, skipping copy"
  else
    $CP /opt/stellar-default/common/stellar-rpc/ $STELLAR_RPC_HOME
    if [ -d /opt/stellar-default/$NETWORK/stellar-rpc/ ]; then
      $CP /opt/stellar-default/$NETWORK/stellar-rpc/ $STELLAR_RPC_HOME
    fi
  fi

  if [ -d $FBHOME/etc ]; then
    echo "friendbot: config directory exists, skipping copy"
  else
    $CP /opt/stellar-default/common/friendbot/ $FBHOME
    if [ -d /opt/stellar-default/$NETWORK/friendbot/ ]; then
      $CP /opt/stellar-default/$NETWORK/friendbot/ $FBHOME
    fi
  fi

  if [ -d $NXHOME/etc ]; then
    echo "nginx: config directory exists, skipping copy"
  else
    $CP /opt/stellar-default/common/nginx/ $NXHOME
    if [ -d /opt/stellar-default/$NETWORK/nginx/ ]; then
      $CP /opt/stellar-default/$NETWORK/nginx/ $NXHOME
    fi
  fi

  if [ -d $GALEXIEHOME/etc ]; then
    echo "galexie: config directory exists, skipping copy"
  else
    $CP /opt/stellar-default/common/galexie/ $GALEXIEHOME
    if [ -d /opt/stellar-default/$NETWORK/galexie/ ]; then
      $CP /opt/stellar-default/$NETWORK/galexie/ $GALEXIEHOME
    fi
  fi
}

function copy_pgpass() {
  local CP="rsync -a"

  $CP /opt/stellar/postgresql/.pgpass /root/
  chmod 0600 /root/.pgpass

  $CP /opt/stellar/postgresql/.pgpass /var/lib/stellar
  chmod 0600 /var/lib/stellar/.pgpass
  chown stellar:stellar /var/lib/stellar/.pgpass
}

function init_db() {
  # Need postgres if horizon is enabled, or if core is enabled and using postgres
  if [ "$ENABLE_HORIZON" != "true" ] && { [ "$ENABLE_CORE" != "true" ] || [ "$CORE_USE_POSTGRES" != "true" ]; }; then
    return 0
  fi
  if [ -f $PGHOME/.quickstart-initialized ]; then
    echo "postgres: already initialized"
    return 0
  fi
  pushd $PGHOME

  # workaround!!!! from: https://github.com/nimiq/docker-postgresql93/issues/2
  mkdir /etc/ssl/private-copy; mv /etc/ssl/private/* /etc/ssl/private-copy/; rm -r /etc/ssl/private; mv /etc/ssl/private-copy /etc/ssl/private; chmod -R 0700 /etc/ssl/private; chown -R postgres /etc/ssl/private
  # end workaround

  echo "postgres user: $PGUSER"

  set_pg_password

  run_silent "finalize-pgpass" perl -pi -e "s/__PGPASS__/$PGPASS/g" /opt/stellar/postgresql/.pgpass

  mkdir -p $PGDATA
  chown postgres:postgres $PGDATA
  chmod 0700 $PGDATA

  # Create /var/run/postgresql because we are starting postgres manually,
  # it is our responsibility to make sure the directory exists for where the
  # process files and unix socket will live.
  mkdir -p /var/run/postgresql
  chown postgres:postgres /var/run/postgresql

  run_silent "init-postgres" sudo -u postgres $PGBIN/initdb -D $PGDATA

  start_postgres
  if [ "$ENABLE_HORIZON" = "true" ]; then
    run_silent "create-horizon-db" sudo -u postgres createdb horizon
  fi
  if [ "$ENABLE_CORE" = "true" ] && [ "$CORE_USE_POSTGRES" = "true" ]; then
    run_silent "create-core-db" sudo -u postgres createdb core
  fi
  run_silent "stellar-postgres-user" sudo -u postgres psql <<-SQL
    CREATE USER $PGUSER WITH PASSWORD '$PGPASS';
    $([ "$ENABLE_HORIZON" = "true" ] && echo "GRANT ALL PRIVILEGES ON DATABASE horizon to $PGUSER;")
    $([ "$ENABLE_CORE" = "true" ] && [ "$CORE_USE_POSTGRES" = "true" ] && echo "GRANT ALL PRIVILEGES ON DATABASE core to $PGUSER;")
SQL

  touch .quickstart-initialized
  popd
}

function init_stellar_core() {
  if [ "$ENABLE_CORE" != "true" ]; then
    return 0
  fi

  run_silent "mkdir-core-log" mkdir -p "$CORELOG"
  run_silent "chown-core-log" chown -R stellar:stellar "$CORELOG"

  pushd $COREHOME
  run_silent "chown-core" chown -R stellar:stellar .

  # Write core environment file for runtime configuration.
  # This runs on every startup to support changing settings on restart.
  # Default to "debug" for local network to maintain backward compatibility.
  local core_log_level="$CORE_LOG_LEVEL"
  if [ -z "$core_log_level" ] && [ "$NETWORK" = "local" ]; then
    core_log_level="debug"
  fi
  cat > $COREHOME/etc/env <<EOF
CORE_LOG_LEVEL="$core_log_level"
CORE_USE_POSTGRES="$CORE_USE_POSTGRES"
EOF

  if [ -f $COREHOME/.quickstart-initialized ]; then
    echo "core: already initialized"

    if [ "$NETWORK" = "local" ]; then
      run_silent "init-core-scp" sudo -u stellar stellar-core force-scp --conf $COREHOME/etc/stellar-core.cfg
    fi

    return 0
  fi

  perl -pi -e "s/__NETWORK__/$NETWORK_PASSPHRASE/g" etc/stellar-core.cfg

  run_silent "finalize-core-config-manual-close" perl -pi -e "s/__MANUAL_CLOSE__/$ENABLE_CORE_MANUAL_CLOSE/g" etc/stellar-core.cfg

  # Set database based on CORE_USE_POSTGRES environment variable
  if [ "$CORE_USE_POSTGRES" = "true" ]; then
    local DATABASE_URL="postgresql://dbname=core host=localhost user=stellar password=$PGPASS"
    start_postgres
  else
    local DATABASE_URL="sqlite3:///opt/stellar/core/stellar.db"
  fi
  run_silent "finalize-core-config-database" perl -pi -e "s|__DATABASE__|$DATABASE_URL|g" etc/stellar-core.cfg

  run_silent "init-core-db" sudo -u stellar stellar-core new-db --conf etc/stellar-core.cfg

  if [ "$NETWORK" = "local" ]; then
    run_silent "init-core-scp" sudo -u stellar stellar-core force-scp --conf etc/stellar-core.cfg

    run_silent "mkdir-history-archive" mkdir -p $HISTORYARCHIVEHOME/data
    run_silent "chown-history-archive" chown -R stellar:stellar $HISTORYARCHIVEHOME
    run_silent "init-history" sudo -u stellar stellar-core new-hist vs --conf $COREHOME/etc/stellar-core.cfg
  fi

  touch .quickstart-initialized
  popd
}

function init_friendbot() {
  if [ -f $FBHOME/.quickstart-initialized ]; then
    echo "friendbot: already initialized"
    return 0
  fi
  pushd $FBHOME

  perl -pi -e "s/__NETWORK__/$NETWORK_PASSPHRASE/g" etc/friendbot.cfg
  perl -pi -e "s/__NETWORK_ROOT_SECRET_KEY__/$NETWORK_ROOT_SECRET_KEY/g" etc/friendbot.cfg

  if [ "$ENABLE_RPC" = "true" ]; then
    echo 'rpc_url = "http://localhost:8003"' >> etc/friendbot.cfg
    echo 'fund_contract_addresses = true' >> etc/friendbot.cfg
  elif [ "$ENABLE_HORIZON" = "true" ]; then
    echo 'horizon_url = "http://localhost:8001"' >> etc/friendbot.cfg
  fi

  touch .quickstart-initialized
  popd
}

function init_horizon() {
  if [ "$ENABLE_HORIZON" != "true" ]; then
    return 0
  fi

  if [ -f $HZHOME/.quickstart-initialized ]; then
    echo "horizon: already initialized"
    return 0
  fi
  pushd $HZHOME

  mkdir ./captive-core
  perl -pi -e "s/__PGPASS__/$PGPASS/g" etc/horizon.env
  perl -pi -e "s/__NETWORK__/$NETWORK_PASSPHRASE/g" etc/horizon.env
  perl -pi -e "s=__ARCHIVE__=$HISTORY_ARCHIVE_URLS=g" etc/horizon.env

  HORIZON_CAPTIVE_CORE_CFG=$HZHOME/etc/stellar-captive-core.cfg
  run_silent "finalize-horizon-captivecore-db" perl -pi -e "s*__DATABASE__*sqlite3://$HZHOME/captive-core/stellar.db*g" $HORIZON_CAPTIVE_CORE_CFG
  perl -pi -e "s/__NETWORK__/$NETWORK_PASSPHRASE/g" $HORIZON_CAPTIVE_CORE_CFG
  run_silent "finalize-horizon-captivecore-config-enable-soroban-diagnostic-events" perl -pi -e "s/__ENABLE_SOROBAN_DIAGNOSTIC_EVENTS__/$ENABLE_SOROBAN_DIAGNOSTIC_EVENTS/g" $HORIZON_CAPTIVE_CORE_CFG

  cat << EOF >> etc/horizon.env
export CAPTIVE_CORE_CONFIG_PATH=$HORIZON_CAPTIVE_CORE_CFG
export CAPTIVE_CORE_STORAGE_PATH=$HZHOME/captive-core
export STELLAR_CORE_VERSION="$(stellar-core version 2>/dev/null | head -1)"
export INGEST_SKIP_PROTOCOL_VERSION_CHECK=$(< /image.json jq -r 'if .config.horizon_skip_protocol_version_check == true then "True" else "" end')
EOF

  run_silent "chown-horizon" chown -R stellar:stellar .

  start_postgres
  run_silent "init-horizon-db" sudo -u stellar ./bin/horizon db init
  touch .quickstart-initialized
  popd
}

function init_stellar_rpc() {
  if [ "$ENABLE_RPC" != "true" ]; then
    return 0
  fi

  if [ -f $STELLAR_RPC_HOME/.quickstart-initialized ]; then
    echo "stellar rpc: already initialized"
    return 0
  fi

  pushd $STELLAR_RPC_HOME
  mkdir ./captive-core

  STELLAR_RPC_CAPTIVE_CORE_CFG=$STELLAR_RPC_HOME/etc/stellar-captive-core.cfg
  run_silent "finalize-stellar-rpc-captivecore-db" perl -pi -e "s*__DATABASE__*sqlite3://$STELLAR_RPC_HOME/captive-core/stellar-rpc.db*g" $STELLAR_RPC_CAPTIVE_CORE_CFG
  perl -pi -e "s/__NETWORK__/$NETWORK_PASSPHRASE/g" $STELLAR_RPC_CAPTIVE_CORE_CFG
  run_silent "finalize-stellar-rpc-captivecore-config-enable-soroban-diagnostic-events" perl -pi -e "s/__ENABLE_SOROBAN_DIAGNOSTIC_EVENTS__/$ENABLE_SOROBAN_DIAGNOSTIC_EVENTS/g" $STELLAR_RPC_CAPTIVE_CORE_CFG

  local ADMIN_ENDPOINT=0.0.0.0:6061
  if [ "$ENABLE_RPC_ADMIN_ENDPOINT" != "true" ]; then
    ADMIN_ENDPOINT=
  fi
  
  perl -pi -e "s/__STELLAR_RPC_ADMIN_ENDPOINT__/$ADMIN_ENDPOINT/g" etc/stellar-rpc.cfg
  perl -pi -e "s/__NETWORK__/$NETWORK_PASSPHRASE/g" etc/stellar-rpc.cfg
  perl -pi -e "s=__ARCHIVE__=$HISTORY_ARCHIVE_URLS=g" etc/stellar-rpc.cfg

  run_silent "init-stellar-rpc" chown -R stellar:stellar .

  touch .quickstart-initialized
  popd
}

function init_galexie() {
  if [ "$ENABLE_GALEXIE" != "true" ]; then
    return 0
  fi

  if [ -f $GALEXIEHOME/.quickstart-initialized ]; then
    echo "galexie: already initialized"
    return 0
  fi

  run_silent "mkdir-ledger-meta-store" mkdir -p $LEDGERMETASTOREHOME/data
  run_silent "chown-ledger-meta-store" chown -R stellar:stellar $LEDGERMETASTOREHOME

  pushd $GALEXIEHOME
  mkdir ./captive-core

  GALEXIE_CAPTIVE_CORE_CFG=$GALEXIEHOME/etc/stellar-captive-core.cfg
  run_silent "finalize-galexie-captivecore-db" perl -pi -e "s*__DATABASE__*$GALEXIEHOME/captive-core/galexie.db*g" $GALEXIE_CAPTIVE_CORE_CFG
  perl -pi -e "s/__NETWORK__/$NETWORK_PASSPHRASE/g" etc/galexie.toml
  perl -pi -e "s/__NETWORK__/$NETWORK_PASSPHRASE/g" etc/stellar-captive-core.cfg

  run_silent "init-galexie" chown -R stellar:stellar .

  touch .quickstart-initialized
  popd
}

function kill_supervisor() {
  kill -3 $(cat "/var/run/supervisord.pid")
}

function fail_soroban_config_upgrade() {
  echo "!!!!! $1. Stopping all services. !!!!!"
  kill_supervisor
  return 1
}

function get_ledger_transaction_count() {
  curl -s http://localhost:11626/metrics | jq -r '.metrics."ledger.transaction.count".count'
}

function wait_for_ledger_transaction_count() {
  while [ "$(get_ledger_transaction_count)" -lt "$1" ]; do
    sleep 1
  done
}

function submit_soroban_config_tx() {
  local label="$1"
  local tx="$2"
  local txid="$3"
  local attempt=1
  local max_attempts=30

  while true; do
    local response
    local status

    response="$(curl -sG 'http://localhost:11626/tx' --data-urlencode "blob=$tx")"
    status="$(echo "$response" | jq -r '.status')"

    echo "upgrades: soroban config: $label: $txid .. $status"

    case "$status" in
      PENDING|DUPLICATE)
        return 0
        ;;
      TRY_AGAIN_LATER)
        if [ "$attempt" -ge "$max_attempts" ]; then
          echo "$response"
          fail_soroban_config_upgrade "Unable to submit Soroban config transaction '$label' after $attempt attempts"
        fi

        attempt=$((attempt+1))
        sleep 1
        ;;
      ERROR|FILTERED)
        echo "$response"
        fail_soroban_config_upgrade "Unable to submit Soroban config transaction '$label'"
        ;;
      *)
        echo "$response"
        fail_soroban_config_upgrade "Unexpected status '$status' while submitting Soroban config transaction '$label'"
        ;;
    esac
  done
}

function apply_soroban_config_tx() {
  submit_soroban_config_tx "$1" "$2" "$3"
  wait_for_ledger_transaction_count "$4"
}

function set_soroban_config_upgrade() {
  local key="$1"
  local attempt=1
  local max_attempts=10

  while true; do
    local output

    output="$(curl -sG 'http://localhost:11626/upgrades?mode=set&upgradetime=1970-01-01T00:00:00Z' --data-urlencode "configupgradesetkey=$key")"
    echo "$output"

    if [ "$output" != "Error setting configUpgradeSet" ]; then
      return 0
    fi

    if [ "$attempt" -ge "$max_attempts" ]; then
      fail_soroban_config_upgrade "Unable to upgrade Soroban Config Settings"
    fi

    attempt=$((attempt+1))
    sleep 1
  done
}

function upgrade_soroban_config() {
  local config_file_path="$1"
  local seq_num="$2"
  local upgrade_output
  local line_count
  
  # Generate txs for installing, deploying and executing the contract that
  # uploads a new config. Use the network root account to submit the txs.
  upgrade_output="$(echo "$NETWORK_ROOT_SECRET_KEY" \
    | stellar-core get-settings-upgrade-txs \
      "$NETWORK_ROOT_ACCOUNT_ID" \
      "$seq_num" \
      "$NETWORK_PASSPHRASE" \
      --xdr "$(stellar-xdr encode --type ConfigUpgradeSet < "$config_file_path")" \
      --signtxs)"

  line_count="$(echo "$upgrade_output" | wc -l | tr -d ' ')"

  if [ "$line_count" -ne 7 ] && [ "$line_count" -ne 9 ]; then
    echo "$upgrade_output"
    fail_soroban_config_upgrade "Unexpected output from stellar-core get-settings-upgrade-txs"
  fi

  echo "$upgrade_output" | {
    local expected_tx_count
    local tx
    local txid
    local key

    expected_tx_count=$(( $(get_ledger_transaction_count) + 1 ))

    # If 9 lines are returned instead of 7, core included a restore transaction.
    if [ "$line_count" -eq 9 ]; then
      read tx
      read txid
      apply_soroban_config_tx "restore contract" "$tx" "$txid" "$expected_tx_count"
      expected_tx_count=$((expected_tx_count+1))
    fi

    read tx
    read txid
    apply_soroban_config_tx "install contract" "$tx" "$txid" "$expected_tx_count"
    expected_tx_count=$((expected_tx_count+1))

    read tx
    read txid
    apply_soroban_config_tx "deploy contract" "$tx" "$txid" "$expected_tx_count"
    expected_tx_count=$((expected_tx_count+1))

    read tx
    read txid
    apply_soroban_config_tx "upload config" "$tx" "$txid" "$expected_tx_count"

    read key
    echo "upgrades: soroban config: set config with key: $key"
    set_soroban_config_upgrade "$key"
  }

  echo "upgrades: soroban config done"
}

function upgrade_local() {
  set -eo pipefail

  trap kill_supervisor ERR

  if [ "$NETWORK" != "local" ]; then
    return
  fi

  # Wait for server
  while ! echo "Stellar-core http server listening!" | nc localhost 11626 &> /dev/null; do sleep 1; done

  if [ ".$PROTOCOL_VERSION" == ".none" ] ; then
    return
  fi

  # Upgrade local network's protocol version and base reserve to match pubnet/testnet
  if [ $PROTOCOL_VERSION -gt 0 ]; then
    echo "upgrades: protocolversion=$PROTOCOL_VERSION, basereserve=5000000"
    curl -s "http://localhost:11626/upgrades?mode=set&upgradetime=1970-01-01T00:00:00Z&protocolversion=$PROTOCOL_VERSION&basereserve=5000000"
    while [ "`curl -s http://localhost:11626/info | jq -r '.info.ledger.version'`" != "$PROTOCOL_VERSION" ]; do sleep 1; done
    echo "upgrades: protocolversion done"
  fi

  # Upgrade local network's soroban config to match testnet, unless the limits
  # have been configured with 'default', which will cause the limits to be left
  # in their default state.
  if [ $PROTOCOL_VERSION -ge 20 ] && [ "$LIMITS" != "default" ]; then
    # Skip if already upgraded because these commands can only be run at the
    # start of the network when the root account has sourced no other
    # transactions.
    if [ -f "$COREHOME/.upgrade-config-initialized" ]; then
      echo "upgrades: soroban config already applied, skipping"
    else
      # First upgrade with the settings_enable_upgrades.json file
      # to enable the upcoming, larger upgrade.
      upgrade_soroban_config "$COREHOME/etc/config-settings/settings_enable_upgrades.json" 0
      
      echo "upgrades: soroban config '$LIMITS' limits"

      # Then upgrade with the existing protocol version specific file
      # Pass the expected sequence number of the root account after the first call to upgrade_soroban_config
      upgrade_soroban_config "$COREHOME/etc/config-settings/p$PROTOCOL_VERSION/$LIMITS.json" 4

      touch "$COREHOME/.upgrade-config-initialized"
    fi
  fi

  # Start friendbot once network upgrades are complete and network is ready.
  # Note that friendbot and the config upgrade txs above use the same
  # account to submit txs. while friend it is not dependent on the config
  # upgrade txs, it must not be started until the config upgrades are
  # complete otherwise the txs sequence numbers will conflict.
  if [ "$ENABLE_HORIZON" == "true" ] || [ "$ENABLE_RPC" == "true" ]; then
      supervisorctl start friendbot
  fi
}

function start_optional_services() {
  while supervisorctl status > /dev/null; [ $? -eq 4 ]; do
    sleep 1
  done

  if [ "$ENABLE_CORE" == "true" ]; then
    if [ "$CORE_USE_POSTGRES" == "true" ]; then
      supervisorctl start postgresql
    fi
    supervisorctl start stellar-core
  fi

  if [ "$ENABLE_HORIZON" == "true" ]; then
    supervisorctl start postgresql
    supervisorctl start horizon
  fi

  if [ "$ENABLE_RPC" == "true" ]; then
    supervisorctl start stellar-rpc
  fi

  if [ "$ENABLE_LAB" == "true" ]; then
    supervisorctl start stellar-lab
  fi

  if [ "$ENABLE_GALEXIE" == "true" ]; then
    supervisorctl start ledger-meta-store
    supervisorctl start galexie
  fi
}

function exec_supervisor() {
  echo "supervisor: starting"
  upgrade_local &
  service_status &
  start_optional_services &
  # Run supervisord in a new environment (using `env -i`) because supervisord
  # inherits the env vars of its environment for all subprocesses that get
  # started. This is problematic for services that use the same environment
  # variable name for things that the start script does, like NETWORK.
  exec env -i supervisord -n -c $SUPHOME/etc/supervisord.conf \
    > >(sed -u 's/^/supervisor: /') \
    2> >(sed -u 's/^/supervisor: /' >&2)
}

function print_service_logs() {
  # Wait for supervisord to be up.
  while ! supervisorctl pid > /dev/null ; do
    sleep 1;
  done
  # Start tailing logs from notable services.
  if [ "$ENABLE_CORE" = "true" ]; then
    supervisorctl tail -f stellar-core stdout > >(sed "s/^/${purple}stellar-core | $clear/") &
    supervisorctl tail -f stellar-core stderr > >(sed "s/^/${purple}stellar-core | $clear/" >&2) &
  fi
  if [ "$ENABLE_HORIZON" = "true" ]; then
    supervisorctl tail -f horizon      stdout > >(sed  "s/^/${green}horizon      | $clear/") &
  fi
  if [ "$ENABLE_RPC" = "true" ]; then
    supervisorctl tail -f stellar-rpc  stdout > >(sed "s/^/${blue}stellar-rpc  | $clear/") &
  fi
}

# run_silent is a utility function that runs a command with an abbreviated
# output provided it succeeds.
function run_silent() {
  local LABEL=$1
  shift
  local COMMAND=$1
  shift
  local ARGS=$@
  local OUTFILE="/tmp/run_silent.out"

  set +e

  $COMMAND $ARGS &> $OUTFILE

  if [ $? -eq 0 ]; then
    echo "$LABEL: ok"
  else
    echo "$LABEL: failed!"
    echo ""
    cat $OUTFILE
    exit 1
  fi

  set -e
}

function start_postgres() {
  if [ ! -z "$CURRENT_POSTGRES_PID" ]; then
    return 0
  fi

  # Check that postgres can start and load the data successfully. If it can't
  # successfully do this, then something is in a bad state. For example, a newer
  # a persistent volume may be mounted with postgres data which is incompatible
  # with the version of postgres in the container. Log any errors from postgres
  # to help the operator debug the situation.
  if ! postgres_logs=$(sudo -u postgres sh -c "echo -n | $PGBIN/postgres --single -E -D $PGDATA -c config_file=$PGHOME/etc/postgresql.conf" 2>&1); then
    echo "$postgres_logs" | sed -u 's/^/postgres: /'
    exit 1
  fi

  sudo -u postgres $PGBIN/postgres -D $PGDATA -c config_file=$PGHOME/etc/postgresql.conf &> /dev/null &
  CURRENT_POSTGRES_PID=$!

  while ! sudo -u postgres psql -c 'select 1' &> /dev/null ; do
    echo "Waiting for postgres to be available..."
    sleep 1
  done

  echo "postgres: up"
}

function stop_postgres() {
  if [ -z "$CURRENT_POSTGRES_PID" ]; then
    return 0
  fi

  killall postgres
  # wait for postgres to die
  while kill -0 "$CURRENT_POSTGRES_PID" &> /dev/null; do
    sleep 0.5
  done
  echo "postgres: down"
}

pushd() {
  command pushd "$@" > /dev/null
}

popd() {
  command popd "$@" > /dev/null
}

function service_status() {
  if [ "$ENABLE_CORE" = "true" ]; then
    stellar_core_status "node" 11626 &
  fi
  if [ "$ENABLE_HORIZON" = "true" ]; then
    stellar_core_status "horizon" 11726 &
    horizon_status &
  fi
  if [ "$ENABLE_RPC" = "true" ]; then
    stellar_core_status "rpc" 11826 &
    stellar_rpc_status &
  fi
}

function stellar_core_status() {
  local name="$1"
  local port="$2"
  local last_status=""
  while true; do
    local status="$(curl --silent --location "http://localhost:${port}/info" | jq -r '"\([.info.state] + (.info.status // []) | join("; "))"')"
    if [ "$status" != "$last_status" ]; then
      echo "stellar-core(${name}): $status"
    fi
    last_status="$status"
    sleep 1
  done
}

function stellar_rpc_status() {
  echo "stellar-rpc: waiting for ready state..."
  COUNTER=1
  while ! $(curl --silent --location --request POST 'http://localhost:8003' \
    --header 'Content-Type: application/json' \
    --data-raw '{ "jsonrpc": "2.0", "id": 10235, "method": "getHealth" }' | \
    jq --exit-status '.result.status == "healthy"' 2>/dev/null | grep -o true || echo false);
  do
    if [ $(expr $COUNTER % 12) -eq 0 ]; then
      echo "stellar-rpc: waiting for ready state, $(expr $COUNTER / 12) minutes..."
    fi
    COUNTER=$[$COUNTER +1]
    sleep 5
  done
  echo "stellar-rpc: up and ready"
}

function horizon_status() {
  COUNTER=1
  echo "horizon: waiting for ingestion to catch up..."
  while ! $(curl --silent --location --request GET 'http://localhost:8001' | \
    jq --exit-status '.core_latest_ledger > 5 and .history_latest_ledger > 5' 2>/dev/null | \
    grep -o true || echo false);
  do
    if [ $(expr $COUNTER % 12) -eq 0 ]; then
      echo "horizon: waiting for ingestion to catch up, $(expr $COUNTER / 12) minutes..."
    fi
    COUNTER=$[$COUNTER +1]
    sleep 5
  done
  echo "horizon: ingestion caught up"
}

main $@