dev

#!/bin/bash
# The MIT License (MIT)
# 
# Copyright (c) 2016 Horatiu Eugen Vlad
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

function usage {
  printf "Development environment in docker containers\n"
  printf "Synopsys:\n"
  printf "  $0 <action> [-h] [-u <user>] [-d <working_directory>] [-e <key=value>] [-p <publish_port>] <image> [<command>] \n"
  printf "\n"
  printf "Arguments:\n"
  printf "  <action> : Action to be executed:\n"
  printf "    run     : run a new container instance.\n"
  printf "    exec    : execute <commands> in running instance.\n"
  printf "    ps      : process status for running instances.\n"
  printf "  <image>   : Docker image name or id.\n"
  printf "\n"
  printf "Options:\n"
  printf "  -d <working_dir> : Working directory that will be mounted in the development container under '/workspace'.\n"
  printf "  -e <key>[=<value>] : environments parameters which should be passed to the docker instance.\n"
  printf "  -p <publish_port>  : Publish a container’s port(s) to the host passed on to docker command.\n"
  printf "  -P                 : Automatically map any network port passed on to docker command.\n"
  printf "  -u <user> : Username.\n"
  printf "  -h        : This help message.\n"
  printf "\n"
  printf "ENVIRONMENT:\n"
  printf "  DEV_DOCKER_OPTIONS: Options that are passed directly to the docker 'run' command. i.e. DEV_DOCKER_OPTIONS='-e BASH_IT_THEME=modern -v /tmp:/tmp'\n"
}

function failed {
  >&2 echo -e "$@"
  exit 1
}

function initialize {
  unset CMD_ACTION
  CMD_DOCKER_OPTIONS=""
  unset CMD_DOCKER_IMAGE
  unset DOCKER_COMMAND
  unset CMD_DOCKER_USER

  CMD_WORKING_DIR=$PWD
  CMD_DOCKER_ENV=""
}

function parse_args # [args ...]
{
  # check paramters
#  if [ $# -lt 1 ]; then
#    usage
#    exit 1
#  fi

  [ $# -lt 1 ] && >&2 echo "Missing command arguments. Check usage using '-h'." && exit 1
  CMD_ACTION=$1
  shift

  typeset opt
  while getopts 'hd:e:u:Pp:' opt ; do
    case "$opt" in
      h)
        usage
        exit 0
        ;;
      d)
        CMD_WORKING_DIR=$OPTARG
        ;;
      e)
        CMD_DOCKER_ENV+=" -e $OPTARG"
        ;;
      u)
        CMD_DOCKER_USER=$OPTARG
        ;;
      P)
        CMD_DOCKER_OPTIONS+=" -P"
        ;;
      p)
        CMD_DOCKER_OPTIONS+=" -p $OPTARG"
        ;;
      *)
        >&2 echo "Invalid option '-$opt'"
        exit 1
        ;;
    esac
  done
  shift $((OPTIND -1))

  [ $# -ne 0 ] && CMD_DOCKER_IMAGE="$1" && shift

  # Make sure all remaining args are passed to docker as command
  if [ $# -ne 0 ] ; then
    DOCKER_COMMAND="$@"
  fi
}

function ask_yes {
  local question=$1

  if [ ${CMD_YES} -eq 1 ] ; then
    # do not ask, answer as if was "yes"
    return 0
  fi

  read -n 1 -r -p "${question} [Y/n] " response
  if [ -n "${response}" ]; then
    echo "" # only one char was typed and no line feed
  else
    response="y"
  fi
  response=${response,,} # tolower
  if [[ $response =~ ^(yes|y| ) ]]; then
    # answer was "yes"
    return 0
  fi
  # aswer was not "yes"
  return 1
}

function find_image_id() {
    local docker_image=$1
    local working_dir=$2
    local image_id=$(docker ps -q | xargs --no-run-if-empty docker inspect --format "{{ if eq .Config.Image \"${docker_image}\" }}{{ range .Mounts }}{{ if eq .Source \"${working_dir}\" }}{{ $.ID }}{{ end }}{{ end }}{{ end }}")

    [[ -z "$image_id" ]] && return 1

    echo $image_id
}

function find_image_name() {
    local docker_image=${1:?Missing docker image.}
    local working_dir=${2:?Missing working directory.}
    local image_name=$(docker ps -q | xargs --no-run-if-empty docker inspect --format "{{ if eq .Config.Image \"${docker_image}\" }}{{ range .Mounts }}{{ if eq .Source \"${working_dir}\" }}{{ $.Name }}{{ end }}{{ end }}{{ end }}")
    image_name=${image_name:1}

    [[ -z "$image_name" ]] && return 1

    echo $image_name
}

function docker_run() {
  local image_name="$(find_image_name "${CMD_DOCKER_IMAGE}" "${CMD_WORKING_DIR}")"

  [[ -n $image_name ]] && >&2 printf "Container '$image_name' for image '${CMD_DOCKER_IMAGE}' already running in working directory '${CMD_WORKING_DIR}'.\nUse command '$0 exec ${CMD_DOCKER_IMAGE} ${CMD_WORKING_DIR}' to enter running container.\n" && exit 1

  mkdir -p ${CMD_WORKING_DIR}/.home
  docker run -it --rm --net=host ${CMD_DOCKER_OPTIONS} ${DEV_DOCKER_OPTIONS} \
    -e USER="$(id -u -n ${CMD_DOCKER_USER})" -e GROUP="$(id -g -n ${CMD_DOCKER_USER})" -u "$(id -u ${CMD_DOCKER_USER}):$(id -g ${CMD_DOCKER_USER})" \
    -v "${CMD_WORKING_DIR}:/workspace" \
    -v "${CMD_WORKING_DIR}/.home:/home/default" \
    -v ~/.ssh:/home/default/.ssh \
    -e DISPLAY="${DISPLAY}" \
    -v ~/.Xauthority:/home/default/.Xauthority \
    -v /dev/shm:/dev/shm \
    ${CMD_DOCKER_ENV} ${CMD_DOCKER_IMAGE} ${DOCKER_COMMAND}
}

function docker_exec() {
  local image_name="$(find_image_name "${CMD_DOCKER_IMAGE}" "${CMD_WORKING_DIR}")"

  if [[ -z "$image_name" ]]; then
    >&2 echo "No container found for image '${CMD_DOCKER_IMAGE}' running in working directory '${CMD_WORKING_DIR}'."
    exit 1
  fi

  docker exec -it ${CMD_DOCKER_USER:+-u ${CMD_DOCKER_USER}} ${image_name} ${DOCKER_COMMAND:-/bin/bash}
}

function docker_ps() {
  local image_name="$(find_image_name "${CMD_DOCKER_IMAGE}" "${CMD_WORKING_DIR}")"

  if [[ -z "$image_name" ]]; then
    >&2 echo "No container found for image '${CMD_DOCKER_IMAGE}' running in working directory '${CMD_WORKING_DIR}'."
    exit 1
  fi

  docker ps --filter "name=$image_name"
}

initialize

parse_args "$@"

case "${CMD_ACTION}" in
  run)
    docker_run
    ;;
  exec)
    docker_exec
    ;;
  ps)
    docker_ps
    ;;
  *)
    >&2 echo "Unknown action: '${CMD_ACTION}'"
    usage
    exit 1
esac