launcher

#!/bin/bash

app_name=intercity
app_path="/var/$app_name"
image=intercity/intercity:0.4.0

command=$1
config=$2

cd "$(dirname "$0")"

docker_min_version='1.2.0'
docker_rec_version='1.2.0'
docker_path=`which docker`

config_file=containers/"$config".yml
local_image_name="local_$app_name"
cidbootstrap=cids/"$config"_bootstrap.cid

if [ "${SUPERVISED}" = "true" ]; then
  restart_policy="--restart=no"
  attach_on_start="-a"
  attach_on_run="-a stdout -a stderr"
else
  attach_on_run="-d"
fi


if [ -n "$DOCKER_HOST" ]; then
  docker_ip=`sed -e 's/^tcp:\/\/\(.*\):.*$/\1/' <<< "$DOCKER_HOST"`
fi

if [ "$opt" == "--docker-args" ] ; then
  user_args=$4
else
  user_args=""
fi

compare_version() {
  declare -a ver_a
  declare -a ver_b
  IFS=. read -a ver_a <<< "$1"
  IFS=. read -a ver_b <<< "$2"

  while [[ -n $ver_a ]]; do
    if (( ver_a > ver_b )); then
      return 0
    elif (( ver_b > ver_a )); then
      return 1
    else
      unset ver_a[0]
      ver_a=("${ver_a[@]}")
      unset ver_b[0]
      ver_b=("${ver_b[@]}")
    fi
  done
  return 1  # They are equal
}

prereqs() {
  # 1. docker daemon running?
  test=`$docker_path info 2> /dev/null`

  if [[ $? -ne 0 ]] ; then
    echo "Cannot connect to the docker daemon - verify it is running and you have access"
    exit 1
  fi

  # 2. running aufs or btrfs
  test=`$docker_path info 2> /dev/null | grep 'Driver: '`
  if [[ "$test" =~ [aufs|btrfs|zfs|overlay] ]] ; then : ; else
    echo "Your Docker installation is not using a supported filesystem if we were to proceed you may have a broken install."
    echo "aufs is the recommended filesystem you should be using (zfs/btrfs and overlay may work as well)"
    echo "You can tell what filesystem you are using by running \"docker info\" and looking at the driver"
    echo ""
    echo "If you wish to continue anyway using your existing unsupported filesystem"
    echo "read the source code of launcher and figure out how to bypass this."
    exit 1
  fi

  # 3. running recommended docker version
  test=($($docker_path --version))  # Get docker version string
  test=${test[2]//,/}  # Get version alone and strip comma if exists

  [[ "$test" =~ "0.12.0" ]] && echo "You are running a broken version of Docker, please upgrade ASAP." && exit 1

  # At least minimum version
  if compare_version "${docker_min_version}" "${test}"; then
    echo "ERROR: Docker version ${test} not supported, please upgrade to at least ${docker_min_version}, or recommended ${docker_rec_version}"
    exit 1
  fi

  # Recommend best version
  if compare_version "${docker_rec_version}" "${test}"; then
    echo "WARNING: Docker version ${test} deprecated, recommend upgrade to ${docker_rec_version} or newer."
  fi

  # 4. App docker image is downloaded
  test=`$docker_path images | awk '{print $1 ":" $2 }' | grep "$image"`

  if [ -z "$test" ]; then
    echo
    echo "WARNING: We are about to start downloading the base image"
    echo "This process may take anywhere between a few minutes to an hour, depending on your network speed"
    echo
    echo "Please be patient"
    echo

  fi

  # 5. able to attach stderr / out / tty
  test=`$docker_path run $user_args -i --rm -a stdout -a stderr $image echo working`
  if [[ "$test" =~ "working" ]] ; then : ; else
    echo "Your Docker installation is not working correctly"
    exit 1
  fi
}

usage () {
  echo "Usage: launcher COMMAND CONFIG [--skip-prereqs]"
  echo "Commands:"
  echo "    start:      Start/initialize a container"
  echo "    stop:       Stop a running container"
  echo "    restart:    Restart a container"
  echo "    destroy:    Stop and remove a container"
  echo "    enter:      Use nsenter to enter a container"
  echo "    rebuild:    Rebuild a container (destroy old, bootstrap, start new)"
  echo "    bootstrap:  Bootstrap a container for the config based on a template"
  exit 1
}

docker_version=($($docker_path --version))
docker_version=${test[2]//,/}

restart_policy=${restart_policy:---restart=always}

set_existing_container(){
  existing=`$docker_path ps -a | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
}

set_template_info() {
    templates=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
      "require 'yaml'; puts YAML.load(STDIN.readlines.join)['templates']"`

    templates_array=(${templates// /})
    config_data=$(cat $config_file)

    input="hack: true"

    for template in "${templates_array[@]}"
    do
      [ ! -z $template ] && {
        input="$input _FILE_SEPERATOR_ $(cat $template)"
      }
    done

    # we always want our config file last so it takes priority
    input="$input _FILE_SEPERATOR_ $config_data"

    read -r -d '' env_ruby << 'RUBY'
    require 'yaml'

    input=STDIN.readlines.join
    # default to UTF-8 for the dbs sake
    env = {'LANG' => 'en_US.UTF-8'}
    input.split('_FILE_SEPERATOR_').each do |yml|
       yml.strip!
       begin
         env.merge!(YAML.load(yml)['env'] || {})
       rescue Psych::SyntaxError => e
        puts e
        puts "*ERROR."
       rescue => e
        puts yml
        p e
       end
    end
    puts env.map{|k,v| "-e\n#{k}=#{v}" }.join("\n")
RUBY

  raw=`exec echo "$input" | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e "$env_ruby"`

  env=()
  ok=1
  while read i; do
    if [ "$i" == "*ERROR." ]; then
      ok=0
    elif [ -n "$i" ]; then
      env[${#env[@]}]=$i
    fi
  done <<< "$raw"

  if [ "$ok" -ne 1 ]; then
    echo "${env[@]}"
    echo "YAML syntax error. Please check your $app_path/containers/*.yml config files."
    exit 1
  fi
}

set_volumes() {
  volumes=`cat $config_file |$docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \ "require 'yaml'; puts YAML.load(STDIN.readlines.join)['volumes'].map{|v| '-v ' << v['volume']['host'] << ':' << v['volume']['guest'] << ' '}.join"`
}

set_links() {
  links=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
    "require 'yaml'; puts YAML.load(STDIN.readlines.join)['links'].map{|l| '--link ' << l['link']['name'] << ':' << l['link']['alias'] << ' '}.join"`
}

run_bootstrap() {
  $docker_path history $image >/dev/null 2>&1 || $docker_path pull $image

  set_template_info

  update_pups=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
    "require 'yaml'; puts YAML.load(STDIN.readlines.join)['update_pups']"`

  set_volumes
  set_links

  rm -f $cidbootstrap

  run_command="cd /pups &&"
  if [[ ! "false" =  $update_pups ]]; then
    run_command="$run_command git pull &&"
  fi
  run_command="$run_command /pups/bin/pups --stdin"

  echo $run_command

  env=("${env[@]}" "-e" "SSH_PUB_KEY=$ssh_pub_key")

  (exec echo "$input" | $docker_path run $user_args $links "${env[@]}" -e DOCKER_HOST_IP=$docker_ip --cidfile $cidbootstrap -i -a stdin -a stdout -a stderr $volumes $image \
    /bin/bash -c "$run_command") \
    || ($docker_path rm `cat $cidbootstrap` && rm $cidbootstrap)

  [ ! -e $cidbootstrap ] && echo "** FAILED TO BOOTSTRAP ** please scroll up and
    look for earlier error messages, there may be more than one" && exit 1

  sleep 5

  $docker_path commit `cat $cidbootstrap` $local_image_name/$config || echo 'FAILED TO COMMIT'
  $docker_path rm `cat $cidbootstrap` && rm $cidbootstrap
}

run_start() {
   existing=`$docker_path ps | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
   echo $existing
   if [ ! -z $existing ]
   then
     echo "Nothing to do, your container has already started!"
     exit 1
   fi


   existing=`$docker_path ps -a | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
   if [ ! -z $existing ]
   then
     echo "starting up existing container"
     (
       set -x
       $docker_path start $config
     )
     exit 0
   fi

   ports=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
          "require 'yaml'; puts YAML.load(STDIN.readlines.join)['expose'].map{|p| '-p ' << p.to_s << ' '}.join"`

   docker_args=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
          "require 'yaml'; puts YAML.load(STDIN.readlines.join)['docker_args']"`

   set_template_info
   set_volumes
   set_links

   (
     hostname=`hostname`
     set -x
     $docker_path run $user_args $links $attach_on_run $restart_policy "${env[@]}" -h "$hostname-$config" \
        -e DOCKER_HOST_IP=$docker_ip --name $config -t $ports $volumes $docker_args $local_image_name/$config \
        /sbin/boot

   )
   exit 0

}

run_stop() {
  set_existing_container

  if [ ! -z $existing ]
    then
      (
        set -x
        $docker_path stop -t 10 $config
      )
    else
      echo "$config was not started !"
      exit 1
  fi
}

prereqs

[ $# -lt 2 ] && {
  usage
}

if [ ! -e $config_file ]
then
  echo "Config file was not found, ensure $config_file exists"
  echo ""
  echo "Available configs ( `cd containers && ls -dm *.yml | tr -s '\n' ' ' | awk '{ gsub(/\.yml/, ""); print }'`)"
  exit 1
fi

case "$command" in
  bootstrap)
    run_bootstrap
    echo "Successfully bootstrapped, to startup use ./launcher start $config"
    exit 0
    ;;
  enter)
    exec $docker_path exec -it $config /bin/bash
    ;;
  rebuild)
      if [ "$(git symbolic-ref --short HEAD)" == "master" ]; then
        echo "Ensuring $app_name docker is up to date"

        git remote update

        LOCAL=$(git rev-parse @)
        REMOTE=$(git rev-parse @{u})
        BASE=$(git merge-base @ @{u})

        if [ $LOCAL = $REMOTE ]; then
          echo "$app_name Docker is up-to-date"

        elif [ $LOCAL = $BASE ]; then
          echo "Updating $app_name Docker"
          git pull || (echo 'failed to update' && exit 1)
          exec /bin/bash $0 $@

        elif [ $REMOTE = $BASE ]; then
          echo "Your version of $app_name Docker is ahead of origin"

        else
          echo "$app_name Docker has diverged source, this is only expected in Dev mode"
        fi

      fi

      set_existing_container

      if [ ! -z $existing ]
        then
          echo "Stopping old container"
          (
            set -x
            $docker_path stop -t 10 $config
          )
      fi

      run_bootstrap

      if [ ! -z $existing ]
        then
          echo "Removing old container"
          (
            set -x
            $docker_path rm $config
          )
      fi

      run_start
      exit 0
      ;;
  stop)
    run_stop
    exit 0
    ;;
  start)
    run_start
    exit 0
    ;;
  restart)
    run_stop
    run_start
    exit 0
    ;;
  destroy)
    (set -x; $docker_path stop -t 10 $config && $docker_path rm $config) || (echo "$config was not found" && exit 0)
    exit 0
    ;;
esac

usage