base_node_binaries.yml

name: Build Matrix of Binaries

on:
  push:
    tags:
      - "v[0-9]+.[0-9]+.[0-9]+"
    branches:
      - build-*
  schedule:
    - cron: "05 00 * * *"
  workflow_dispatch:
    inputs:
      customTag:
        description: "Development Tag"
        required: true
        default: "development-tag"

env:
  TBN_FILENAME: "tari_base_node"

jobs:
  builds:
    name: Build and deploy tari_base_node
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-18.04, macos-10.15, windows-2019]
        # https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html
        target_cpu: ["x86-64"]
        # https://github.com/zkcrypto/curve25519-dalek-ng/pull/14
        # target_cpu: ["haswell"]
        # exclude:
        #   - os: "macos-10.15"
        #     target_cpu: "haswell"
        # include:
        #   - os: "macos-10.15"
        #     target_cpu: "x86-64"

    runs-on: ${{ matrix.os }}

    steps:
      - name: Checkout source code
        uses: actions/checkout@v2

      - name: Declare Global Variables 4 GHA ${{ github.event_name }}
        id: vars
        shell: bash
        run: |
          echo "VBRANCH=$(echo ${GITHUB_REF#refs/heads/})" >> $GITHUB_ENV
          echo "VSHA_SHORT=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
          echo "CARGO_HTTP_MULTIPLEXING=false" >> $GITHUB_ENV

      - name: Default Destination Folder
        run: |
          echo "S3DESTOVERRIDE=" >> $GITHUB_ENV

      - name: Scheduled Destination Folder Override
        if: ${{ github.event_name == 'schedule' && github.event.schedule == '05 00 01 * *' }}
        run: |
          echo "S3DESTOVERRIDE=daily/" >> $GITHUB_ENV

      - name: Setup Rust toolchain
        uses: actions-rs/toolchain@v1
        with:
          toolchain: nightly-2021-09-18
          components: rustfmt
          override: true

      - name: Install Linux dependencies - Ubuntu
        if: startsWith(runner.os,'Linux')
        run: |
          sudo apt-get update
          sudo apt-get -y install \
            openssl \
            libssl-dev \
            pkg-config \
            libsqlite3-dev \
            clang-10 \
            git \
            cmake \
            libc++-dev \
            libc++abi-dev \
            libprotobuf-dev \
            protobuf-compiler \
            libncurses5-dev \
            libncursesw5-dev \
            zip
      #        sudo apt-get -y upgrade
      - name: Install macOS dependencies
        if: startsWith(runner.os,'macOS')
        run: brew install cmake zip coreutils

      - name: Install Windows dependencies
        if: startsWith(runner.os,'Windows')
        run: |
          vcpkg.exe install sqlite3:x64-windows zlib:x64-windows
          choco upgrade llvm zip psutils openssl strawberryperl -y

      - name: Set environment variables - Nix
        if: "!startsWith(runner.os,'Windows')"
        run: |
          echo "SHARUN=shasum --algorithm 256" >> $GITHUB_ENV
          echo "CC=gcc" >> $GITHUB_ENV
          echo "TBN_EXT=" >> $GITHUB_ENV
          echo "S3DESTDIR=linux" >> $GITHUB_ENV
          echo "TBN_DIST=/dist" >> $GITHUB_ENV

      - name: Set environment variables - macOS
        if: startsWith(runner.os,'macOS')
        run: |
          echo "S3DESTDIR=osx" >> $GITHUB_ENV

      - name: Set environment variables - Windows
        if: startsWith(runner.os,'Windows')
        shell: bash
        run: |
          echo "SHARUN=pwsh C:\ProgramData\chocolatey\lib\psutils\tools\psutils-master\shasum.ps1 --algorithm 256" >> $GITHUB_ENV
          echo "TBN_EXT=.exe" >> $GITHUB_ENV
          echo "TBN_DIST=\dist" >> $GITHUB_ENV
          echo "S3DESTDIR=windows" >> $GITHUB_ENV
          echo "SQLITE3_LIB_DIR=C:\vcpkg\installed\x64-windows\lib" >> $GITHUB_ENV
          echo "OPENSSL_DIR=C:\Program Files\OpenSSL-Win64" >> $GITHUB_ENV
          echo "LIBCLANG_PATH=C:\Program Files\LLVM\bin" >> $GITHUB_ENV
          echo "C:\Strawberry\perl\bin" >> $GITHUB_PATH

      - name: Caching
        uses: actions/cache@v2
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ runner.os }}-${{ matrix.os }}-${{ matrix.target_cpu }}-${{ matrix.features }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}

      - name: Build binaries
        env:
          RUSTFLAGS: "-C target_cpu=${{ matrix.target_cpu }}"
          ROARING_ARCH: "${{ matrix.target_cpu }}"
        run: |
          echo "Cache Key: ${{ runner.os }}-${{ matrix.os }}-${{ matrix.target_cpu }}-${{ matrix.features }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}"
          #cd applications/tari_base_node
          #cargo build --release --bin tari_base_node --features ${{ matrix.features}}
          cargo build --release

        #  - name: Prepare Archives
        #    shell: bash
        #    run: |
        #      ls -la "$GITHUB_WORKSPACE"
        #      mkdir -p "$GITHUB_WORKSPACE${TBN_DIST}/archives"
        #      export distDir="$GITHUB_WORKSPACE${TBN_DIST}/archives"
        #      "$GITHUB_WORKSPACE/scripts/build_dists_tarball.sh" noBuild

      - name: Prepare binaries
        shell: bash
        run: |
          mkdir -p "$GITHUB_WORKSPACE${TBN_DIST}"
          cd "$GITHUB_WORKSPACE${TBN_DIST}"
          VERSION=$(awk -F ' = ' '$1 ~ /version/ { gsub(/[\"]/, "", $2); printf("%s",$2) }' "$GITHUB_WORKSPACE/applications/tari_base_node/Cargo.toml")
          echo "Branch: ${VBRANCH}"
          echo "Sha: ${VSHA_SHORT}"
          echo "VERSION=${VERSION}" >> $GITHUB_ENV
          echo "VSHA_SHORT=${VSHA_SHORT}" >> $GITHUB_ENV
          #BINFILE="${TBN_FILENAME}-${VERSION}-${VSHA_SHORT}-${{ matrix.os }}-${{ matrix.target_cpu }}-${{ matrix.features }}${TBN_EXT}"
          BINFILE="${TBN_FILENAME}-${VERSION}-${VSHA_SHORT}-${{ matrix.os }}-${{ matrix.target_cpu }}${TBN_EXT}"
          echo "BINFILE=${BINFILE}" >> $GITHUB_ENV
          echo "Copying files for ${BINFILE} to $(pwd)"
          #cp -v "$GITHUB_WORKSPACE/target/release/${TBN_FILENAME}${TBN_EXT}" "./${BINFILE}"
          ls -la "$GITHUB_WORKSPACE/target/release/"
          cp -v "$GITHUB_WORKSPACE/target/release/tari_base_node${TBN_EXT}" .
          cp -v "$GITHUB_WORKSPACE/target/release/tari_console_wallet${TBN_EXT}" .
          cp -v "$GITHUB_WORKSPACE/target/release/tari_merge_mining_proxy${TBN_EXT}" .
          cp -v "$GITHUB_WORKSPACE/target/release/tari_mining_node${TBN_EXT}" .

      - name: Build the macos pkg
        if: startsWith(runner.os,'macOS')
        env:
          MACOS_KEYCHAIN_PASS: ${{ secrets.MACOS_KEYCHAIN_PASS }}
          MACOS_APPLICATION_CERT: ${{ secrets.MACOS_APPLICATION_CERT }}
          MACOS_APPLICATION_PASS: ${{ secrets.MACOS_APPLICATION_PASS }}
          MACOS_INSTALLER_CERT: ${{ secrets.MACOS_INSTALLER_CERT }}
          MACOS_INSTALLER_PASS: ${{ secrets.MACOS_INSTALLER_PASS }}
        run: |
          echo $MACOS_APPLICATION_CERT | base64 --decode > application.p12
          echo $MACOS_INSTALLER_CERT | base64 --decode > installer.p12
          security create-keychain -p $MACOS_KEYCHAIN_PASS build.keychain
          security default-keychain -s build.keychain
          security unlock-keychain -p $MACOS_KEYCHAIN_PASS build.keychain
          security import application.p12 -k build.keychain -P $MACOS_APPLICATION_PASS -T /usr/bin/codesign
          security import installer.p12 -k build.keychain -P $MACOS_INSTALLER_PASS -T /usr/bin/pkgbuild
          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k $MACOS_KEYCHAIN_PASS build.keychain
          cd buildtools
          ./create_osx_install_zip.sh unused nozip
          FILES=("tari_base_node" "tari_console_wallet" "tari_mining_node" "tari_merge_mining_proxy")
          for FILE in "${FILES[@]}"; do
            codesign --force -s "Developer ID Application: Tari Labs, LLC (8XGMD9X2H2)" "/tmp/tari_testnet/runtime/$FILE" -v
            codesign --verify --deep --display --verbose=4 "/tmp/tari_testnet/runtime/$FILE"
          done
          pkgbuild --root /tmp/tari_testnet \
          --identifier "com.tarilabs.pkg" \
          --version "$VERSION" \
          --install-location "/tmp/tari" \
          --scripts "/tmp/tari_testnet/scripts" \
          --sign "Developer ID Installer: Tari Labs, LLC (8XGMD9X2H2)" \
          "${{ github.workspace }}${{ env.TBN_DIST }}/tari-${{ env.VERSION }}.pkg"
      - name: Artifact macos pkg
        if: startsWith(runner.os,'macOS')
        uses: actions/upload-artifact@v2
        with:
          name: tari-${{ env.VERSION }}.pkg
          path: "${{ github.workspace }}${{ env.TBN_DIST }}/tari-${{ env.VERSION }}.pkg"

      # unlike inno script studio, iscc.exe doesn't run the [precompile] step generate_config.bat
      - name: Build the windows installer
        shell: cmd
        if: startsWith(runner.os,'Windows')
        run: |
          cd buildtools
          call generate_config.bat
          "%programfiles(x86)%\Inno Setup 6\iscc.exe" "/DMyAppVersion=${{ env.VERSION }}-${{ env.VSHA_SHORT }}-release" "windows_inno_installer.iss"

      - name: Upload artifact for Windows installer
        uses: actions/upload-artifact@v2
        if: startsWith(runner.os,'Windows')
        with:
          name: "tari_windows_installer"
          path: "${{ github.workspace }}/buildtools/Output/*"

      - name: Archive and Sign Binaries
        shell: bash
        run: |
          echo "Archive ${{ env.BINFILE }} too ${{ env.BINFILE }}.zip"
          cd "$GITHUB_WORKSPACE${{ env.TBN_DIST }}"
          #zip -j "${{ env.BINFILE }}.zip" "${{ env.BINFILE }}"
          zip -j "${{ env.BINFILE }}.zip" *
          echo "Compute shasum"
          ${SHARUN} "${{ env.BINFILE }}.zip" >> "${{ env.BINFILE }}.zip.sha256"
          cat "${{ env.BINFILE }}.zip.sha256"
          echo "Verifications is "
          ${SHARUN} --check "${{ env.BINFILE }}.zip.sha256"
          #rm -f "${BINFILE}"

      - name: Artifact archive
        uses: actions/upload-artifact@v2
        with:
          #name: ${{ env.TBN_FILENAME }}-${{ env.VERSION }}-${{ env.VSHA_SHORT }}-${{ matrix.os }}-${{ matrix.target_cpu }}-${{ matrix.features }}
          name: tari_binary_archive-${{ matrix.os }}-${{ matrix.target_cpu }}
          path: "${{ github.workspace }}${{ env.TBN_DIST }}/${{ env.BINFILE }}.zip*"

      - name: Artifact miner
        uses: actions/upload-artifact@v2
        with:
          name: tari_mining_node-${{ matrix.os }}-${{ matrix.target_cpu }}
          path: "${{ github.workspace }}${{ env.TBN_DIST }}/tari_mining_node${{ env.TBN_EXT}}"

      - name: Sync dist to S3 - Bash
        continue-on-error: true # Don't break if s3 upload fails
        if: ${{ env.AWS_SECRET_ACCESS_KEY != '' && matrix.os != 'self-hosted' }}
        shell: bash
        run: |
          echo "Starting upload ... ${{ env.SOURCE }}"
          if [ "$RUNNER_OS" == "Windows" ]; then
            echo "No ls for 'D:' on Windows"
          else
            ls -al ${{ env.SOURCE }}
          fi
          aws s3 ${{ env.S3CMD }} --region ${{ secrets.AWS_REGION }} \
            "${{ env.SOURCE }}" \
            s3://${{ secrets.AWS_S3_BUCKET }}/${{ env.DEST_DIR }} \
            ${{ env.S3OPTIONS }}
          echo "Done - $?"
          exit 0
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          SOURCE: "${{ github.workspace }}${{ env.TBN_DIST }}"
          DEST_DIR: "${{ env.S3DESTOVERRIDE }}${{ env.S3DESTDIR }}/"
          S3CMD: "cp"
          S3OPTIONS: '--recursive --exclude "*" --include "*.zip*"'
          # S3OPTIONS: '--recursive --exclude "*" --include "*.zip*"'
          # S3OPTIONS: '--acl public-read'

      - name: Copy tags to latest s3 - Bash
        #      if: ${{ env.AWS_SECRET_ACCESS_KEY != '' && matrix.os != 'self-hosted' }}
        if: ${{ env.AWS_SECRET_ACCESS_KEY != '' && matrix.os != 'self-hosted' && startsWith(github.ref, 'refs/tags/v') }}
        shell: bash
        run: |
          echo "Starting upload ... ${{ env.SOURCE }}"
          if [ "$RUNNER_OS" == "Windows" ]; then
            echo "No ls for 'D:' on Windows"
          else
            ls -al ${{ env.SOURCE }}
          fi

          aws s3 ${{ env.S3CMD }} --region ${{ secrets.AWS_REGION }} \
                    "${{ env.SOURCE }}" \
                    s3://${{ secrets.AWS_S3_BUCKET }}/current/${{ env.DEST_DIR }} \
                    ${{ env.S3OPTIONS }}

          aws s3 rm --region ${{ secrets.AWS_REGION }} \
                              s3://${{ secrets.AWS_S3_BUCKET }}/latest/${{ env.DEST_DIR }}/*

          aws s3 ${{ env.S3CMD }} --region ${{ secrets.AWS_REGION }} \
            "${{ env.SOURCE }}" \
            s3://${{ secrets.AWS_S3_BUCKET }}/latest/${{ env.DEST_DIR }} \
            ${{ env.S3OPTIONS }}
          echo "Done - $?"
          exit 0
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          SOURCE: "${{ github.workspace }}${{ env.TBN_DIST }}"
          DEST_DIR: "${{ env.S3DESTOVERRIDE }}${{ env.S3DESTDIR }}/"
          S3CMD: "cp"
          S3OPTIONS: '--recursive --exclude "*" --include "*.zip*"'
          # S3OPTIONS: '--recursive --exclude "*" --include "*.zip*"'
          # S3OPTIONS: '--acl public-read'

  create-release:
    runs-on: ubuntu-latest
    needs: builds
    if: ${{ startsWith(github.ref, 'refs/tags/v') }}
    steps:
      - name: Download binaries
        uses: actions/download-artifact@v2
      - name: Create release
        uses: ncipollo/release-action@v1
        with:
          artifacts: "tari_*/**/*"
          token: ${{ secrets.GITHUB_TOKEN }}
          prerelease: true
          draft: true