Automate YugabyteDB Release Downloads and Installations with Bash

				
					#!/usr/bin/env bash

set -Eeuo pipefail

VERSION=""
OS_ARCH=""
DEST_DIR="."
DOWNLOAD=false
INSTALL=false
VERIFY=true

if [[ -t 1 && -z "${NO_COLOR:-}" ]]; then
  GREEN='\033[0;32m'
  CYAN='\033[0;36m'
  YELLOW='\033[1;33m'
  RED='\033[0;31m'
  NC='\033[0m'
else
  GREEN=''
  CYAN=''
  YELLOW=''
  RED=''
  NC=''
fi

info() { printf '%b[INFO]%b %s\n' "$CYAN" "$NC" "$*"; }
ok()   { printf '%b[ OK ]%b %s\n' "$GREEN" "$NC" "$*"; }
warn() { printf '%b[WARN]%b %s\n' "$YELLOW" "$NC" "$*" >&2; }
die()  { printf '%b[ERROR]%b %s\n' "$RED" "$NC" "$*" >&2; exit 1; }

usage() {
  cat <<USAGE
Usage:
  $0 -v <version> [options]

Required:
  -v, --version <version>       YugabyteDB version, for example 2025.2.3.1

Options:
  -o, --os-arch <value>         Package platform. Auto-detected when omitted.
                                Supported values:
                                  linux-x86_64
                                  el8-aarch64
                                  darwin-x86_64
                                  darwin-arm64
  -d, --download                Download and verify the tarball
  -i, --install                 Download, verify, extract, and prepare it
                                Implies --download
  -C, --directory <path>        Download and extract under this directory
                                Default: current directory
      --no-verify               Skip checksum verification
  -h, --help                    Show this help

Examples:
  $0 -v 2024.2.10.0
  $0 -v 2025.2.3.1 -d
  $0 -v 2026.1.0.1 -i -C /opt/yugabyte
  $0 -v 2026.1.0.1 -o darwin-arm64 -i
USAGE
}

need_value() {
  [[ $# -ge 2 && -n "${2:-}" ]] ||
    die "Option $1 requires a value."
}

require_command() {
  command -v "$1" >/dev/null 2>&1 ||
    die "Required command not found: $1"
}

detect_os_arch() {
  local os machine

  os="$(uname -s)"
  machine="$(uname -m)"

  case "${os}:${machine}" in
    Linux:x86_64|Linux:amd64)
      printf '%s\n' 'linux-x86_64'
      ;;
    Linux:aarch64|Linux:arm64)
      printf '%s\n' 'el8-aarch64'
      ;;
    Darwin:x86_64|Darwin:amd64)
      printf '%s\n' 'darwin-x86_64'
      ;;
    Darwin:arm64|Darwin:aarch64)
      printf '%s\n' 'darwin-arm64'
      ;;
    *)
      die "Unable to map ${os}/${machine} to a YugabyteDB package. Use --os-arch."
      ;;
  esac
}

validate_os_arch() {
  case "$1" in
    linux-x86_64|el8-aarch64|darwin-x86_64|darwin-arm64)
      ;;
    *)
      die "Unsupported OS/architecture: $1"
      ;;
  esac
}

fetch_release_page() {
  local series="$1"
  local candidate_url

  for candidate_url in \
    "https://docs.yugabyte.com/stable/releases/ybdb-releases/v${series}/" \
    "https://docs.yugabyte.com/stable/releases/ybdb-releases/end-of-life/v${series}/"
  do
    if RELEASE_HTML="$(
      curl -fsSL \
        --retry 3 \
        --connect-timeout 15 \
        --user-agent 'get_ybdb.sh/1.0' \
        "$candidate_url"
    )"; then
      DOCS_URL="$candidate_url"
      return 0
    fi
  done

  return 1
}

calculate_checksum() {
  local file="$1"
  local checksum_length="$2"

  case "$checksum_length" in
    40)
      if command -v shasum >/dev/null 2>&1; then
        shasum -a 1 "$file" | awk '{print $1}'
      elif command -v sha1sum >/dev/null 2>&1; then
        sha1sum "$file" | awk '{print $1}'
      else
        die "Checksum verification requires shasum or sha1sum."
      fi
      ;;
    64)
      if command -v shasum >/dev/null 2>&1; then
        shasum -a 256 "$file" | awk '{print $1}'
      elif command -v sha256sum >/dev/null 2>&1; then
        sha256sum "$file" | awk '{print $1}'
      else
        die "Checksum verification requires shasum or sha256sum."
      fi
      ;;
    *)
      die "Unexpected checksum length: ${checksum_length}"
      ;;
  esac
}

while [[ $# -gt 0 ]]; do
  case "$1" in
    -v|--version)
      need_value "$@"
      VERSION="$2"
      shift 2
      ;;
    -o|--os-arch)
      need_value "$@"
      OS_ARCH="$2"
      shift 2
      ;;
    -d|--download)
      DOWNLOAD=true
      shift
      ;;
    -i|--install)
      INSTALL=true
      DOWNLOAD=true
      shift
      ;;
    -C|--directory)
      need_value "$@"
      DEST_DIR="$2"
      shift 2
      ;;
    --no-verify)
      VERIFY=false
      shift
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    --)
      shift
      break
      ;;
    *)
      die "Unknown option: $1. Use --help for usage."
      ;;
  esac
done

[[ -n "$VERSION" ]] || {
  usage
  die "A YugabyteDB version is required."
}

[[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]] ||
  die "Version must contain four numeric components, for example 2025.2.3.1."

require_command curl
require_command grep
require_command awk
require_command tr
require_command uname

if [[ -z "$OS_ARCH" ]]; then
  OS_ARCH="$(detect_os_arch)"
  info "Auto-detected package platform: $OS_ARCH"
fi

validate_os_arch "$OS_ARCH"

IFS='.' read -r VERSION_MAJOR VERSION_MINOR _ <<< "$VERSION"
SERIES="${VERSION_MAJOR}.${VERSION_MINOR}"

info "Finding YugabyteDB ${VERSION} release metadata..."

if ! fetch_release_page "$SERIES"; then
  die "Unable to find a release page for YugabyteDB series v${SERIES}."
fi

VERSION_REGEX="${VERSION//./\\.}"

TARBALL_URL="$(
  {
    printf '%s' "$RELEASE_HTML" |
      grep -oE \
        "https://(software|downloads)\.yugabyte\.com/releases/${VERSION_REGEX}/yugabyte-${VERSION_REGEX}-b[0-9]+-${OS_ARCH}\.tar\.gz" |
      awk 'NR == 1 { first = $0 } END { print first }'
  } || true
)"

if [[ -z "$TARBALL_URL" ]]; then
  die "No ${OS_ARCH} tarball was found for YugabyteDB ${VERSION}. Check ${DOCS_URL}"
fi

TARBALL_FILE="${TARBALL_URL##*/}"
CHECKSUM_URL="${TARBALL_URL%.tar.gz}-tar.gz.sha"
TARGET_FILE="${DEST_DIR%/}/${TARBALL_FILE}"

printf '\n%bResolved wget command:%b\n' "$YELLOW" "$NC"
printf 'wget "%s"\n\n' "$TARBALL_URL"

if [[ "$DOWNLOAD" != true ]]; then
  exit 0
fi

require_command wget
mkdir -p "$DEST_DIR"

info "Downloading ${TARBALL_FILE}..."

(
  cd "$DEST_DIR"
  wget --continue "$TARBALL_URL"
)

ok "Downloaded ${TARGET_FILE}"

if [[ "$VERIFY" == true ]]; then
  info "Retrieving and verifying the published checksum..."

  if ! EXPECTED_CHECKSUM="$(
    curl -fsSL --retry 3 "$CHECKSUM_URL" |
      tr -d '\r\n[:space:]'
  )"; then
    die "Unable to retrieve checksum from ${CHECKSUM_URL}"
  fi

  [[ "$EXPECTED_CHECKSUM" =~ ^[0-9a-fA-F]+$ ]] ||
    die "The release server returned an invalid checksum."

  ACTUAL_CHECKSUM="$(
    calculate_checksum "$TARGET_FILE" "${#EXPECTED_CHECKSUM}"
  )"

  EXPECTED_CHECKSUM="$(
    printf '%s' "$EXPECTED_CHECKSUM" |
      tr 'A-F' 'a-f'
  )"

  ACTUAL_CHECKSUM="$(
    printf '%s' "$ACTUAL_CHECKSUM" |
      tr 'A-F' 'a-f'
  )"

  [[ "$ACTUAL_CHECKSUM" == "$EXPECTED_CHECKSUM" ]] ||
    die "Checksum verification failed for ${TARGET_FILE}."

  ok "Checksum verified"
else
  warn "Checksum verification was skipped."
fi

if [[ "$INSTALL" != true ]]; then
  exit 0
fi

require_command tar

EXTRACTED_DIR_NAME="$(
  tar -tzf "$TARGET_FILE" |
    awk -F/ '
      NF && first == "" {
        first = $1
      }
      END {
        print first
      }
    '
)"

[[ -n "$EXTRACTED_DIR_NAME" ]] ||
  die "Unable to determine the archive's top-level directory."

EXTRACTED_DIR="${DEST_DIR%/}/${EXTRACTED_DIR_NAME}"

if [[ -d "$EXTRACTED_DIR" ]]; then
  warn "The extraction directory already exists: ${EXTRACTED_DIR}"
fi

info "Extracting ${TARBALL_FILE}..."

tar -xzf "$TARGET_FILE" -C "$DEST_DIR"

ok "Extracted to ${EXTRACTED_DIR}"

case "$OS_ARCH" in
  linux-*|el8-*)
    [[ -x "$EXTRACTED_DIR/bin/post_install.sh" ]] ||
      die "Expected ${EXTRACTED_DIR}/bin/post_install.sh was not found or is not executable."

    info "Running bin/post_install.sh..."

    (
      cd "$EXTRACTED_DIR"
      ./bin/post_install.sh
    )

    ok "post_install.sh completed"
    ;;
  darwin-*)
    info "The macOS package does not require post_install.sh."
    ;;
esac

printf '\n%bYugabyteDB %s is ready.%b\n' \
  "$GREEN" "$VERSION" "$NC"

printf 'cd %q\n' "$EXTRACTED_DIR"
printf './bin/yugabyted start\n'

if [[ "$OS_ARCH" == darwin-* ]]; then
  printf '\nIf macOS blocks the downloaded binaries, run:\n'
  printf 'xattr -dr com.apple.quarantine %q\n' "$EXTRACTED_DIR"
fi