aboriginal-start

#!/bin/bash

SB_DIRECTORY=
SB_EMULATOR=
SB_INTERACTIVE=false
SB_WORKDIR=
SB_SILENT=false
SB_CPUS=3

#####################################################
#          Usage and command line parsing           #
#####################################################
function usage () {
    echo "Usage: "
    echo "  aboriginal-start [OPTIONS]"
    echo
    echo "Starts the emulator so that it's ready to receive build commands"
    echo
    echo "General Options:"
    echo "  -h --help                       Display this help message and exit"
    echo "  -e --emulator       <path>      Directory of the aboriginal system image"
    echo "  -d --directory      <directory> Directory to share with the aboriginal emulator"
    echo "  -w --workdir        <directory> Directory to keep some state"
    echo "  -c --cpus           <number>    Amount of distcc processes to export for the build slave"
    echo "  -s --silent                     Run silently unless an error occurs"
    echo "  -i --interactive                Run an interactive shell instead of launching the interpretor"
    echo
}

while : ; do
    case "$1" in 
	-h|--help)
	    usage;
	    exit 0;
	    shift ;;

	-d|--directory)
	    SB_DIRECTORY=${2};
	    shift 2 ;;

	-w|--workdir)
	    SB_WORKDIR=${2};
	    shift 2 ;;

	-e|--emulator)
	    SB_EMULATOR=${2};
	    shift 2 ;;

	-c|--cpus)
	    SB_CPUS=${2};
	    shift 2 ;;

	-s|--silent)
	    SB_SILENT=true;
	    shift ;;

	-i|--interactive)
	    SB_INTERACTIVE=true;
	    shift ;;

	*)
	    break ;;
    esac
done


#####################################################
#                 Sanity Checking                   #
#####################################################
function isNumber() {
  if [[ $1 != *[!0-9]* ]]; then
    echo "yes"
  else
    echo "no"
  fi
}

function ensurePipe() {
  if [ ! -p ${1} ]; then
    mkfifo ${1}
    if [ "$?" -ne "0" ]; then
      echo "Failed to named pipe at '${1}'"
      exit 1;
    fi
  fi

  # Clear pipes at startup
  dd if=${1} iflag=nonblock of=/dev/null > /dev/null 2>&1
}

if [ ! -f ${CONTROL_IMAGE} ]; then
  echo "Control image could not be found at '${CONTROL_IMAGE}'"
  exit 1;
fi

if [ -z "${SB_DIRECTORY}" ]; then
  echo "Must specify the directory to share with the emulator"
  echo
  usage
  exit 1;
elif [ ! -d ${SB_DIRECTORY} ]; then
  echo "The specified share directory '${SB_DIRECTORY}' is not a directory"
  echo
  usage
  exit 1;
fi

if [ -z "${SB_WORKDIR}" ]; then
  echo "Must specify the directory to store sandbox running state"
  echo
  usage
  exit 1;
elif [ ! -d ${SB_WORKDIR} ]; then
  mkdir -p ${SB_WORKDIR};
  if [ "$?" -ne "0" ]; then
    echo "Failed to create workdir at '${SB_WORKDIR}'"
    exit 1;
  fi
fi

if [ -z "${SB_EMULATOR}" ]; then
  echo "Must specify the aboriginal emulator directory"
  echo
  usage
  exit 1;
elif [ ! -d ${SB_EMULATOR} ]; then
  echo "The specified emulator '${SB_EMULATOR}' is not a directory"
  echo
  usage
  exit 1;
fi

if [ "$(isNumber ${SB_CPUS})" == "no" ]; then
  echo "The --cpus option must be a numeric value"
  echo
  usage
  exit 1;
fi

# Source the common protocol definition and work directory state
#
SB_PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
. ${SB_PATH}/control/bin/protocol
. ${SB_PATH}/aboriginal-state


# Early abort if we're already running
#
if [ "$(isRunning)" == "1" ]; then
  if ! $SB_SILENT; then
    echo "Aboriginal sandbox for work directory ${SB_WORKDIR} is already running at pid $(cat ${PID_FILE})";
  fi
  exit 0;
fi

ensurePipe ${COMM_IN}
ensurePipe ${COMM_OUT}
#####################################################
#                    Utilities                      #
#####################################################
function waitReady() {
    local tries=0
    local ready=false
    local readAck="z"

    # Here we give it a VERY LONG TIME to come up and be ready,
    # this is because when starting a work directory for the first
    # time it must create a 1GB swap file which takes some time in
    # the emulator to do.
    #
    while [ "${tries}" -lt 100 ]; do

      read -r readAck < ${COMM_IN};
      if [ "${readAck}" == "${SB_PROTO_READY}" ]; then
	ready=true;
	break;
      fi

      let tries=${tries}+1;
    done

    if ! $ready; then
      echo "Unable to ready ready byte from aboriginal sandbox"
      exit 1;
    fi
}

#####################################################
#                      Main                         #
#####################################################
CONTROL_IMAGE="$SB_PATH/control.sqf"

HDB=${IMAGE_FILE}
HDC=$(realpath ${CONTROL_IMAGE})
EMULATOR_DIR=$(realpath ${SB_EMULATOR})
BUILD_PAUSE=0

# Setup virtfs sharing
#
SHARE_DIR=$(realpath ${SB_DIRECTORY})
QEMU_EXTRA="-virtfs local,path=${SHARE_DIR},security_model=mapped-file,mount_tag=share"

# Setup virtio serial device
#
QEMU_EXTRA=$QEMU_EXTRA" -device virtio-serial "
QEMU_EXTRA=$QEMU_EXTRA" -chardev pipe,path=${COMM_OUT},id=comm0"
QEMU_EXTRA=$QEMU_EXTRA" -device virtserialport,chardev=comm0,name=serial0"
QEMU_EXTRA=$QEMU_EXTRA" -chardev pipe,path=${COMM_IN},id=comm1"
QEMU_EXTRA=$QEMU_EXTRA" -device virtserialport,chardev=comm1,name=serial1"

#
# Run the emulator through aboriginal's dev-environment script
#
export CPUS=${SB_CPUS}
export HDB HDC QEMU_EXTRA BUILD_PAUSE DISTCC_LOG
cd ${EMULATOR_DIR}

if $SB_INTERACTIVE; then
  export KERNEL_EXTRA="INTERACTIVE=1"
  ./dev-environment.sh
else
  export NOCONSOLE="1"
  ./dev-environment.sh > ${QEMU_LOG} 2>&1 &
  ABORIGINAL_PID=$!

  # Wait for the emulator to come up
  waitReady

  if ! $SB_SILENT; then
    echo "Sandbox is running at PID ${ABORIGINAL_PID}, ready for commands"
  fi
  echo ${ABORIGINAL_PID} > ${PID_FILE}
fi