build

#!/bin/bash

ARGUMENTS="$@"
CWD=$(pwd)
# https://stackoverflow.com/questions/59895/getting-the-source-directory-of-a-bash-script-from-within
DIRNAME="$(dirname "$(readlink -f "$0")")"

# with help from https://stackoverflow.com/a/29754866,

# saner programming env: these switches turn some bugs into errors
set -o errexit -o pipefail -o noclobber -o nounset

DOCKER="docker"
set +e
if ! $DOCKER ps >/dev/null; then
  echo "error connecting to docker:"
  $DOCKER ps
  exit 1
fi
set -e

! getopt --test > /dev/null 
if [[ ${PIPESTATUS[0]} -ne 4 ]]; then
    echo "GNU's enhanced getopt is required to run this script"
    echo "You can usually find this in the util-linux package"
    echo "On MacOS/OS X see homebrew's package: http://brewformulas.org/Gnu-getopt"
    echo "For anyone else, build from source: http://frodo.looijaard.name/project/getopt"
    exit 1
fi

OPTIONS=hi:o:
LONGOPTS=help,input:,output:,arch:,arm-version:,platform:

# -use ! and PIPESTATUS to get exit code with errexit set
# -temporarily store output to be able to check for errors
# -activate quoting/enhanced mode (e.g. by writing out “--options”)
# -pass arguments only via   -- "$@"   to separate them correctly
! PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTS --name "$0" -- "$@")
if [[ ${PIPESTATUS[0]} -ne 0 ]]; then
    # e.g. return value is 1
    #  then getopt has complained about wrong arguments to stdout
    exit 2
fi
# read getopt’s output this way to handle the quoting right:
eval set -- "$PARSED"

HELP=n 
ARCH=${ARCH:-} ARM_VERSION=${ARM_VERSION:-} PLATFORM=${PLATFORM:-}
INPUT="${CWD}" OUTPUT=prebuilds
while true; do
    case "$1" in
        -h|--help)
            HELP=y
            shift
            ;;
        -i|--input)
            INPUT="$2"
            shift 2
            ;;
        -o|--output)
            OUTPUT="$2"
            shift 2
            ;;
        --arch)
            ARCH="$2"
            shift 2
            ;;
        --arm-version)
            ARM_VERSION="$2"
            shift 2
            ;;
        --platform)
            PLATFORM="$2"
            shift 2
            ;;
        --)
            shift
            break
            ;;
        *)
            echo "Programming error"
            exit 3
            ;;
    esac
done

if
  [ "${HELP}" == "y" ] || \
  [ "${ARCH}" == "" ] || \
  !( [ "${ARCH}" != "x32" ] && [ "${ARCH}" != "x64" ] && [ "${ARCH}" != "arm" ] && [ "${ARCH}" != "arm64" ] ) || \
  [ "${PLATFORM}" == "" ] || \
  !( [ "${PLATFORM}" != "android" ] && [ "${PLATFORM}" != "linux" ] ) || \
  [ "${ARCH}" == "arm" ] && [ "${ARM_VERSION}" == "" ]
then
  cat >&2 <<EOF
Usage:
  prebuildify-cross [options]

  Arguments:

    --arch <arch>: **required** architecture (supported: x32, x64, arm, arm64)
    --arm-version <version>: if using arm architecture, **required* arm version (supported: 5, 6, 7, 8)
    --platform: **required** platform (supported: linux, android)

    --input <path>: _optional_ directory of input image spec (default: cwd)
    --output <path>: _optional_ directory to output build results (default: prebuilds)

  Flags:

    -h, --help: show this usage

  Examples:

    prebuildify-cross --platform linux --arch x64

    prebuildify-cross --platform linux --arch arm --arm-version 7

    prebuildify-cross --platform linux --arch arm64

    prebuildify-cross --platform android --arch arm --arm-version 7

    prebuildify-cross --platform android --arch arm64
EOF
  exit 1
fi

if [[ "${INPUT}" != /* ]]
then
  INPUT="${CWD}/${INPUT}"
fi

if [[ "${OUTPUT}" != /* ]]
then
  OUTPUT="${CWD}/${OUTPUT}"
fi

echo input $INPUT
echo output $OUTPUT

if [ "${ARM_VERSION}" == "8" ]
then
  ARCH=arm64
fi

if [ "${ARCH}" == "arm64" ]
then
  ARM_VERSION=8
fi

function not_supported () {
  if [ "${ARM_VERSION}" == "" ]
  then
    echo "platform=${PLATFORM}, arch=${ARCH}: not supported!"
  else
    echo "platform=${PLATFORM}, arch=${ARCH}, arm_version=${ARM_VERSION}: not supported!"
  fi
  exit 1
}

case "${PLATFORM}" in
  "android")
    case "${ARM_VERSION}" in
      7)
        TARGET=android-arm
        ;;
      8)
        TARGET=android-arm64
        ;;
      *)
        not_supported
        ;;
    esac
    ;;
  "linux")
    case "${ARM_VERSION}" in
      5|6|7)
        TARGET="linux-armv${ARM_VERSION}"
        ;;
      8)
        TARGET=linux-arm64
        ;;
      "")
        TARGET=linux-${ARCH}
        ;;
      *)
        not_supported
        ;;
    esac
    ;;
  *)
    not_supported
    ;;
esac

IMAGE_NAME=${IMAGE_NAME:-prebuildify-cross}
CONTAINER_NAME=${CONTAINER_NAME:-prebuildify-cross-work-${TARGET}}

CONTAINER_RUNNING=$($DOCKER ps --filter name="$CONTAINER_NAME" -q)
if [ "$CONTAINER_RUNNING" != "" ]; then
  $DOCKER stop ${CONTAINER_NAME} > /dev/null
fi

CONTAINER_EXISTS=$($DOCKER ps -a --filter name="$CONTAINER_NAME" -q)
if [ "$CONTAINER_EXISTS" != "" ]; then
  $DOCKER rm -v "${CONTAINER_NAME}"
fi

function cleanup {
  echo 'got EXIT signal... please wait'

  CONTAINER_RUNNING=$($DOCKER ps --filter name="${CONTAINER_NAME}" -q)
  if [ "${CONTAINER_RUNNING}" != "" ]; then
    $DOCKER stop ${CONTAINER_NAME} > /dev/null
  fi

  CONTAINER_EXISTS=$($DOCKER ps -a --filter name="${CONTAINER_NAME}" -q)
  if [ "${CONTAINER_EXISTS}" != "" ]; then
    $DOCKER rm -v ${CONTAINER_NAME} > /dev/null
  fi
}

trap cleanup EXIT

echo ARCH "${ARCH}"
echo ARM_VERSION "${ARM_VERSION}"
echo PLATFORM "${PLATFORM}"
echo TARGET "${TARGET}"

# build target image
$DOCKER build \
  --build-arg TARGET="${TARGET}" \
  -t ${IMAGE_NAME}:${TARGET} \
  ${DIRNAME}

$DOCKER run \
  --name "${CONTAINER_NAME}" \
  -d \
  -v "${INPUT}:/app/input" \
  --env ARCH="${ARCH}" \
  --env ARM_VERSION="${ARM_VERSION}" \
  --env PLATFORM="${PLATFORM}" \
  ${IMAGE_NAME}:${TARGET} \
  bash -e -o errexit -o pipefail -o noclobber -o nounset -c "
    cd /app; ./build-in-docker ${ARGUMENTS};
  "
time $DOCKER logs "${CONTAINER_NAME}" --follow || true &
wait "$!"

echo "copying results from output/"
$DOCKER cp "${CONTAINER_NAME}":/app/output/. "${OUTPUT}"
ls -lah "${OUTPUT}"

echo "Done! Your prebuilds should be in ${OUTPUT}"