#!/usr/bin/env bash

# Build release archives of one binary for every platform from Linux:

#   Linux x86_64 and arm64 (glibc 2.28 and later): .tar.gz and .deb

#   macOS x86_64 and arm64: .tar.gz

#   Windows x86_64: .zip

# plus the hub server for Linux x86_64 on PostgreSQL (oxygenhub-server-*),

# and SHA256SUMS, in target/dist/VERSION.

#

#   scripts/dist.sh [VERSION]    (default: the package version)

#   ONLY=linux-x86_64 scripts/dist.sh   builds one platform (a glob)

#

# Needs: rustup targets x86_64-pc-windows-gnu, aarch64-unknown-linux-gnu,

# x86_64-apple-darwin and aarch64-apple-darwin; cargo-zigbuild and zig on

# PATH (Linux with an old glibc, and macOS without Apple's SDK); the

# MinGW-w64 gcc (Windows); dpkg-deb and zip.

set -euo pipefail

PKG=oh                   # the cargo package

BIN=oh                   # the binary it builds

DEB_NAME=oh              # the Debian package

OTHER_DEB=oxy            # the other package sharing the apt repository files

SUMMARY="OxygenHub from the command line"

DESCRIPTION="oh talks to an OxygenHub (such as https://oxygenhub.io): issues,

 proposals and their reviews, releases, Flow runs and checks, from the

 terminal. It works alongside oxy, the Oxygen version control client."

HOMEPAGE="https://oxygenhub.io/andymccall/oxygenhub"

MAINTAINER="Andy McCall <[email protected]>"

DOCS=(README.md LICENSE docs/oh.md)

cd "$(dirname "$0")/.."

VERSION="${1:-$(cargo metadata --no-deps --format-version 1 | python3 -c "import json,sys; print(next(p['version'] for p in json.load(sys.stdin)['packages'] if p['name']=='$PKG'))")}"

VERSION="${VERSION#v}"

OUT="target/dist/$VERSION"

rm -rf "$OUT" && mkdir -p "$OUT"

export PATH="$HOME/.local/opt/zig:$PATH"

# Stripped, with no debug info: these are for people, not for debugging.

export CARGO_PROFILE_RELEASE_DEBUG=0 CARGO_PROFILE_RELEASE_STRIP=true CARGO_INCREMENTAL=0

# The version the binary reports.

export OXY_BUILD="v$VERSION"

# target triple | platform name | build tool | Debian architecture

PLATFORMS=(

  "x86_64-unknown-linux-gnu.2.28|linux-x86_64|zig|amd64"

  "aarch64-unknown-linux-gnu.2.28|linux-arm64|zig|arm64"

  "x86_64-apple-darwin|macos-x86_64|zig|"

  "aarch64-apple-darwin|macos-arm64|zig|"

  "x86_64-pc-windows-gnu|windows-x86_64|cargo|"

)

for p in "${PLATFORMS[@]}"; do

  IFS='|' read -r target platform tool deb <<<"$p"

  triple="${target%%.2.*}"

  # ONLY=linux-x86_64 (a glob) builds just the platforms it matches.

  if [ -n "${ONLY:-}" ] && [[ "$platform" != $ONLY ]]; then continue; fi

  echo "== $platform ($target)"

  if [ "$tool" = zig ]; then

    cargo zigbuild -q --release --locked --target "$target" -p "$PKG"

  else

    cargo build -q --release --locked --target "$target" -p "$PKG"

  fi

  exe="$BIN"

  [[ "$triple" == *windows* ]] && exe="$BIN.exe"

  built="target/$triple/release/$exe"

  name="$BIN-$VERSION-$platform"

  stage="$OUT/stage/$name"

  mkdir -p "$stage"

  cp "$built" "$stage/"

  cp "${DOCS[@]}" "$stage/"

  if [[ "$triple" == *windows* ]]; then

    # PowerShell's built-in alias `oh` (Out-Host) hides oh.exe (#319):

    # ohub.exe is the same program under a name nothing hides, and

    # install.ps1 puts both on PATH and removes the alias in the profile.

    cp "$built" "$stage/ohub.exe"

    cp packaging/windows/install.ps1 "$stage/"

    (cd "$OUT/stage" && zip -qr "../$name.zip" "$name")

  else

    tar -C "$OUT/stage" -czf "$OUT/$name.tar.gz" "$name"

  fi

  if [ -n "$deb" ]; then

    root="$OUT/stage/deb-$deb"

    mkdir -p "$root/DEBIAN" "$root/usr/bin" "$root/usr/share/doc/$DEB_NAME"

    install -m 0755 "$built" "$root/usr/bin/$BIN"

    cp README.md docs/oh.md "$root/usr/share/doc/$DEB_NAME/"

    cp LICENSE "$root/usr/share/doc/$DEB_NAME/copyright"

    # The apt repository at oxygenhub.io (oxygenhub#85): the package ships

    # the archive's key and, on its first install, adds the repository, so

    # apt upgrade keeps it current. oxy and oh share the files they write.

    mkdir -p "$root/usr/share/$DEB_NAME"

    install -m 0644 packaging/oxygenhub-archive-keyring.gpg "$root/usr/share/$DEB_NAME/"

    sed "s/@PKG@/$DEB_NAME/" >"$root/DEBIAN/postinst" <<'EOF'

#!/bin/sh

set -e

if [ "$1" = configure ]; then

  # The key is refreshed on every install, so a new one reaches everyone.

  install -m 0644 /usr/share/@PKG@/oxygenhub-archive-keyring.gpg /usr/share/keyrings/oxygenhub-archive-keyring.gpg

  # The repository is added on the first install only: removing it

  # keeps it removed.

  L=/etc/apt/sources.list.d/oxygenhub.sources

  if [ -z "$2" ] && [ ! -e "$L" ] && ! grep -rqs "oxygenhub.io/apt" /etc/apt/sources.list /etc/apt/sources.list.d; then

    cat >"$L" <<SRC

Types: deb

URIs: https://oxygenhub.io/apt

Suites: stable

Components: main

Signed-By: /usr/share/keyrings/oxygenhub-archive-keyring.gpg

SRC

  fi

fi

EOF

    sed "s/@OTHER@/$OTHER_DEB/" >"$root/DEBIAN/postrm" <<'EOF'

#!/bin/sh

set -e

if [ "$1" = purge ] && ! dpkg-query -W -f='${Status}' @OTHER@ 2>/dev/null | grep -q "ok installed"; then

  rm -f /etc/apt/sources.list.d/oxygenhub.sources /usr/share/keyrings/oxygenhub-archive-keyring.gpg

fi

EOF

    chmod 0755 "$root/DEBIAN/postinst" "$root/DEBIAN/postrm"

    cat >"$root/DEBIAN/control" <<EOF

Package: $DEB_NAME

Version: $VERSION

Architecture: $deb

Maintainer: $MAINTAINER

Depends: libc6 (>= 2.28)

Section: vcs

Priority: optional

Homepage: $HOMEPAGE

Installed-Size: $(du -sk "$root/usr" | cut -f1)

Description: $SUMMARY

 $DESCRIPTION

EOF

    dpkg-deb --build --root-owner-group -Zxz "$root" "$OUT/${DEB_NAME}_${VERSION}_$deb.deb" >/dev/null

  fi

done

# The hub server for oxygenhub.io on Google Cloud (oxygenhub-gcp's image

# job, phase 6): Linux x86_64, PostgreSQL (docs/postgres.md), glibc 2.28.

# Earth and small hubs build their own SQLite one (docs/deploy.md).

if [ -z "${ONLY:-}" ] || [[ server-linux-x86_64 == $ONLY ]]; then

  echo "== server-linux-x86_64 (postgres)"

  cargo zigbuild -q --release --locked --target x86_64-unknown-linux-gnu.2.28 -p oxygenhub --bin oxygenhub --features postgres

  name="oxygenhub-server-$VERSION-linux-x86_64"

  stage="$OUT/stage/$name"

  mkdir -p "$stage"

  cp target/x86_64-unknown-linux-gnu/release/oxygenhub "$stage/"

  cp LICENSE docs/postgres.md docs/deploy.md "$stage/"

  tar -C "$OUT/stage" -czf "$OUT/$name.tar.gz" "$name"

fi

# The source as released (oxygen#157): the oxygenhub tree with its subrepos (deps/), so oh builds from it alone,

# under oxygenhub-VERSION/, for packagers (haikuports) to fetch from the

# release at a fixed checksum. Reproducible: sorted, fixed times and

# owners, gzip without a timestamp.

if [ -z "${ONLY:-}" ] || [[ src == $ONLY ]]; then

  echo "== src"

  tar --sort=name --mtime='1970-01-01 00:00:00Z' --owner=0 --group=0 --numeric-owner \

    --mode='u+rwX,go+rX,go-w' --exclude=./target --exclude=.oxy \

    --transform "s|^\.|oxygenhub-$VERSION|" -cf - . | gzip -9n >"$OUT/$BIN-$VERSION-src.tar.gz"

fi

rm -rf "$OUT/stage"

(cd "$OUT" && shopt -s nullglob && sha256sum -- *.tar.gz *.zip *.deb >SHA256SUMS)

# DIST_FLAT=DIR: the same files again under names without the version, for

# a pipeline whose artifacts are fixed paths (the OxygenFlow dist job); the

# bytes are the release's, so its assets show as built by that job.

if [ -n "${DIST_FLAT:-}" ]; then

  mkdir -p "$DIST_FLAT"

  for f in "$OUT"/*.tar.gz "$OUT"/*.zip "$OUT"/*.deb "$OUT"/SHA256SUMS; do

    [ -e "$f" ] || continue

    b=$(basename "$f"); b=${b/-$VERSION-/-}; b=${b/_${VERSION}_/_}

    cp "$f" "$DIST_FLAT/$b"

  done

fi

echo "== $OUT"

ls -l "$OUT"