Justfile

#!/usr/bin/env just --justfile

build-release-artifacts arch nightly="false":
  #!/usr/bin/env bash
  set -e

  arch="{{arch}}"
  nightly="{{nightly}}"
  supported_archs=(
    "x86_64-pc-windows-msvc"
    "x86_64-apple-darwin"
    "aarch64-apple-darwin"
    "x86_64-unknown-linux-musl"
    "arm-unknown-linux-musleabi"
    "armv7-unknown-linux-musleabihf"
    "aarch64-unknown-linux-musl"
  )

  arch_supported=false
  for supported_arch in "${supported_archs[@]}"; do
    if [[ "$arch" == "$supported_arch" ]]; then
      arch_supported=true
      break
    fi
  done

  if [[ "$arch_supported" == "false" ]]; then
    echo "$arch is not supported."
    exit 1
  fi

  if [[ "$arch" == "x86_64-unknown-linux-musl" ]]; then
    if [[ "$(grep -E '^NAME="Ubuntu"' /etc/os-release)" ]]; then
      # This is intended for use on a fresh Github Actions agent
      sudo apt update -y
      sudo apt-get install -y musl-tools
    fi
  fi

  rustup target add {{arch}}

  rm -rf artifacts
  mkdir artifacts
  cargo clean

  nightly_feature=""
  if [[ "$nightly" == "true" ]]; then
    nightly_feature="--features nightly"
  fi

  if [[ $arch == arm* || $arch == armv7* || $arch == aarch64* ]]; then
    cargo binstall --no-confirm cross
    build_cmd="cross build --release --target $arch"
  else
    build_cmd="cargo build --release --target $arch"
  fi

  if [[ "${BUILD_NAT_DETECTION:-true}" == "true" ]]; then
    $build_cmd --bin nat-detection $nightly_feature
  fi

  if [[ "${BUILD_NODE_LAUNCHPAD:-true}" == "true" ]]; then
    $build_cmd --bin node-launchpad $nightly_feature
  fi

  if [[ "${BUILD_ANT:-true}" == "true" ]]; then
    $build_cmd --bin ant $nightly_feature --features loud
  fi

  if [[ "${BUILD_ANTNODE:-true}" == "true" ]]; then
    $build_cmd --bin antnode $nightly_feature
  fi

  if [[ "${BUILD_ANTCTL:-true}" == "true" ]]; then
    $build_cmd --bin antctl $nightly_feature
  fi

  if [[ "${BUILD_ANTCTLD:-true}" == "true" ]]; then
    $build_cmd --bin antctld $nightly_feature
  fi

  if [[ "${BUILD_ANTNODE_RPC_CLIENT:-true}" == "true" ]]; then
    $build_cmd --bin antnode_rpc_client $nightly_feature
  fi

  if [[ "${BUILD_EVM_TESTNET:-true}" == "true" ]]; then
    $build_cmd --bin evm-testnet $nightly_feature
  fi

  find target/$arch/release -maxdepth 1 -type f -exec cp '{}' artifacts \;
  rm -f artifacts/.cargo-lock

# Debugging target that builds an `artifacts` directory to be used with packaging targets.
#
# To use, download the artifact zip files from the workflow run and put them in an `artifacts`
# directory here. Then run the target.
make-artifacts-directory:
  #!/usr/bin/env bash
  set -e

  architectures=(
    "x86_64-pc-windows-msvc"
    "x86_64-apple-darwin"
    "aarch64-apple-darwin"
    "x86_64-unknown-linux-musl"
    "arm-unknown-linux-musleabi"
    "armv7-unknown-linux-musleabihf"
    "aarch64-unknown-linux-musl"
  )
  cd artifacts
  for arch in "${architectures[@]}" ; do
    mkdir -p $arch/release
    unzip autonomi-$arch.zip -d $arch/release
    rm autonomi-$arch.zip
  done

package-all-bins:
  #!/usr/bin/env bash
  set -e
  just package-bin "nat-detection"
  just package-bin "node-launchpad"
  just package-bin "ant"
  just package-bin "antnode"
  just package-bin "antctl"
  just package-bin "antctld"
  just package-bin "antnode_rpc_client"
  just package-bin "evm-testnet"

package-bin bin version="":
  #!/usr/bin/env bash
  set -e

  architectures=(
    "x86_64-pc-windows-msvc"
    "x86_64-apple-darwin"
    "aarch64-apple-darwin"
    "x86_64-unknown-linux-musl"
    "arm-unknown-linux-musleabi"
    "armv7-unknown-linux-musleabihf"
    "aarch64-unknown-linux-musl"
  )

  bin="{{bin}}"

  supported_bins=(\
    "nat-detection" \
    "node-launchpad" \
    "ant" \
    "antnode" \
    "antctl" \
    "antctld" \
    "antnode_rpc_client" \
    "evm-testnet")
  crate_dir_name=""

  bin="{{bin}}"
  case "$bin" in
    nat-detection)
      crate_dir_name="nat-detection"
      ;;
    node-launchpad)
      crate_dir_name="node-launchpad"
      ;;
    ant)
      crate_dir_name="ant-cli"
      ;;
    antnode)
      crate_dir_name="ant-node"
      ;;
    antctl)
      crate_dir_name="ant-node-manager"
      ;;
    antctld)
      crate_dir_name="ant-node-manager"
      ;;
    antnode_rpc_client)
      crate_dir_name="ant-node-rpc-client"
      ;;
    evm-testnet)
      crate_dir_name="evm-testnet"
      ;;
    *)
      echo "The $bin binary is not supported"
      exit 1
      ;;
  esac

  if [[ -z "{{version}}" ]]; then
    version=$(grep "^version" < $crate_dir_name/Cargo.toml | \
        head -n 1 | awk '{ print $3 }' | sed 's/\"//g')
  else
    version="{{version}}"
  fi

  if [[ -z "$version" ]]; then
    echo "Error packaging $bin. The version number was not retrieved."
    exit 1
  fi

  rm -rf packaged_bins/$bin
  find artifacts/ -name "$bin" -exec chmod +x '{}' \;
  for arch in "${architectures[@]}" ; do
    echo "Packaging for $arch..."
    if [[ $arch == *"windows"* ]]; then bin_name="${bin}.exe"; else bin_name=$bin; fi
    zip -j $bin-$version-$arch.zip artifacts/$arch/release/$bin_name
    tar -C artifacts/$arch/release -zcvf $bin-$version-$arch.tar.gz $bin_name
  done

  mkdir -p packaged_bins/$bin
  mv *.tar.gz packaged_bins/$bin
  mv *.zip packaged_bins/$bin

upload-all-packaged-bins-to-s3:
  #!/usr/bin/env bash
  set -e

  binaries=(
    nat-detection
    node-launchpad
    ant
    antnode
    antctl
    antnode_rpc_client
    antctld
    evm-testnet
  )
  for binary in "${binaries[@]}"; do
    just upload-packaged-bin-to-s3 "$binary"
  done

upload-packaged-bin-to-s3 bin_name:
  #!/usr/bin/env bash
  set -e

  case "{{bin_name}}" in
    nat-detection)
      bucket="nat-detection"
      ;;
    node-launchpad)
      bucket="node-launchpad"
      ;;
    ant)
      bucket="autonomi-cli"
      ;;
    antnode)
      bucket="antnode"
      ;;
    antctl)
      bucket="antctl"
      ;;
    antctld)
      bucket="antctl"
      ;;
    antnode_rpc_client)
      bucket="antnode-rpc-client"
      ;;
    evm-testnet)
      bucket="evm-testnet"
      ;;
    *)
      echo "The {{bin_name}} binary is not supported"
      exit 1
      ;;
  esac

  cd packaged_bins/{{bin_name}}
  for file in *.zip *.tar.gz; do
    dest="s3://$bucket/$file"
    if [[ "$file" == *latest* ]]; then
      echo "Allowing overwrite for 'latest' version..."
      aws s3 cp "$file" "$dest" --acl public-read
    else
      if aws s3 ls "$dest" > /dev/null 2>&1; then
        echo "$dest already exists. Will not overwrite."
      else
        # This command outputs a lot text which makes the build log difficult to read, so we will
        # suppress it.
        aws s3 cp "$file" "$dest" --acl public-read > /dev/null 2>&1
        echo "$dest uploaded"
      fi
    fi
  done

delete-s3-bin bin_name version:
  #!/usr/bin/env bash
  set -e

  case "{{bin_name}}" in
    nat-detection)
      bucket="nat-detection"
      ;;
    node-launchpad)
      bucket="node-launchpad"
      ;;
    ant)
      bucket="autonomi-cli"
      ;;
    antnode)
      bucket="antnode"
      ;;
    antctl)
      bucket="antctl"
      ;;
    antctld)
      bucket="antctl"
      ;;
    antnode_rpc_client)
      bucket="antnode-rpc-client"
      ;;
    evm-testnet)
      bucket="evm-testnet"
      ;;
    *)
      echo "The {{bin_name}} binary is not supported"
      exit 1
      ;;
  esac

  architectures=(
    "x86_64-pc-windows-msvc"
    "x86_64-apple-darwin"
    "aarch64-apple-darwin"
    "x86_64-unknown-linux-musl"
    "arm-unknown-linux-musleabi"
    "armv7-unknown-linux-musleabihf"
    "aarch64-unknown-linux-musl"
  )

  for arch in "${architectures[@]}"; do
    zip_filename="{{bin_name}}-{{version}}-${arch}.zip"
    tar_filename="{{bin_name}}-{{version}}-${arch}.tar.gz"
    s3_zip_path="s3://$bucket/$zip_filename"
    s3_tar_path="s3://$bucket/$tar_filename"
    aws s3 rm "$s3_zip_path"
    echo "deleted $s3_zip_path"
    aws s3 rm "$s3_tar_path"
    echo "deleted $s3_tar_path"
  done

package-all-architectures:
  #!/usr/bin/env bash
  set -e

  architectures=(
    "x86_64-pc-windows-msvc"
    "x86_64-apple-darwin"
    "aarch64-apple-darwin"
    "x86_64-unknown-linux-musl"
    "arm-unknown-linux-musleabi"
    "armv7-unknown-linux-musleabihf"
    "aarch64-unknown-linux-musl"
  )

  rm -rf packaged_architectures
  for arch in "${architectures[@]}" ; do
    echo "Packaging artifacts for $arch..."
    just package-arch "$arch"
  done

package-arch arch:
  #!/usr/bin/env bash
  set -e

  if [[ -n $PACKAGE_VERSION ]]; then
    version="$PACKAGE_VERSION"
  else
    release_year=$(grep 'release-year:' release-cycle-info | awk '{print $2}')
    release_month=$(grep 'release-month:' release-cycle-info | awk '{print $2}')
    release_cycle=$(grep 'release-cycle:' release-cycle-info | awk '{print $2}')
    release_cycle_counter=$(grep 'release-cycle-counter:' release-cycle-info | awk '{print $2}')
    version="$release_year.$release_month.$release_cycle.$release_cycle_counter"
  fi
  architecture="{{arch}}"
  zip_filename="${version}.autonomi.${architecture}.zip"

  mkdir -p packaged_architectures
  cd artifacts/$architecture/release

  binaries=(
    nat-detection
    node-launchpad
    ant
    antnode
    antctl
    antnode_rpc_client
    antctld
    evm-testnet
  )

  if [[ "$architecture" == *"windows"* ]]; then
    for binary in "${binaries[@]}"; do
      binaries_with_extension+=("$binary.exe")
    done
    zip "../../../packaged_architectures/$zip_filename" "${binaries_with_extension[@]}"
  else
    zip "../../../packaged_architectures/$zip_filename" "${binaries[@]}"
  fi

  cd ../../..

build-artifact-hashes:
  #!/usr/bin/env bash
  set -e

  architectures=(
    "x86_64-pc-windows-msvc"
    "x86_64-apple-darwin"
    "aarch64-apple-darwin"
    "x86_64-unknown-linux-musl"
    "arm-unknown-linux-musleabi"
    "armv7-unknown-linux-musleabihf"
    "aarch64-unknown-linux-musl"
  )

  binaries=(
    "nat-detection"
    "node-launchpad"
    "ant"
    "antnode"
    "antctl"
    "antctld"
    "antnode_rpc_client"
    "evm-testnet"
  )

  echo "## Binary Hashes"
  echo ""

  for arch in "${architectures[@]}"; do
    echo "### $arch"
    echo ""
    echo "| Binary | SHA256 Hash |"
    echo "|--------|-------------|"

    for binary in "${binaries[@]}"; do
      if [[ "$arch" == *"windows"* ]]; then
        binary_path="artifacts/$arch/release/${binary}.exe"
      else
        binary_path="artifacts/$arch/release/${binary}"
      fi

      if [[ -f "$binary_path" ]]; then
        hash=$(sha256sum "$binary_path" | awk '{print $1}')
        echo "| $binary | \`$hash\` |"
      else
        echo "| $binary | *not found* |"
      fi
    done
  done

build-binary-versions:
  #!/usr/bin/env bash
  set -e

  binaries=(
    "antnode"
    "antctl"
    "antctld"
    "ant"
    "evm-testnet"
    "nat-detection"
    "node-launchpad"
  )

  echo "## Binary Versions"
  echo ""

  for binary in "${binaries[@]}"; do
    # Map binary name to crate directory name
    case "$binary" in
      nat-detection)
        crate_dir_name="nat-detection"
        ;;
      node-launchpad)
        crate_dir_name="node-launchpad"
        ;;
      ant)
        crate_dir_name="ant-cli"
        ;;
      antnode)
        crate_dir_name="ant-node"
        ;;
      antctl)
        crate_dir_name="ant-node-manager"
        ;;
      antctld)
        crate_dir_name="ant-node-manager"
        ;;
      antnode_rpc_client)
        crate_dir_name="ant-node-rpc-client"
        ;;
      evm-testnet)
        crate_dir_name="evm-testnet"
        ;;
      *)
        echo "Error: Unknown binary $binary" >&2
        exit 1
        ;;
    esac

    version=$(grep "^version" < $crate_dir_name/Cargo.toml | \
        head -n 1 | awk '{ print $3 }' | sed 's/\"//g')
    if [[ -z "$version" ]]; then
      echo "Error: Could not extract version for $binary from $crate_dir_name/Cargo.toml" >&2
      exit 1
    fi

    # Ensure version has 'v' prefix
    [[ ! "$version" =~ ^v ]] && version="v$version"
    echo "* \`$binary\`: $version"
  done
  echo ""