launcher

   1 #!/bin/bash
   2
   3 usage () {
   4   echo "Usage: launcher COMMAND CONFIG [--skip-prereqs] [--docker-args STRING]"
   5   echo "Commands:"
   6   echo "    start:       Start/initialize a container"
   7   echo "    stop:        Stop a running container"
   8   echo "    restart:     Restart a container"
   9   echo "    destroy:     Stop and remove a container"
  10   echo "    enter:       Open a shell to run commands inside the container"
  11   echo "    logs:        View the Docker logs for a container"
  12   echo "    bootstrap:   Bootstrap a container for the config based on a template"
  13   echo "    run:         Run the given command with the config in the context of the last bootstrapped image"
  14   echo "    rebuild:     Rebuild a container (destroy old, bootstrap, start new)"
  15   echo "    cleanup:     Remove all containers that have stopped for > 24 hours"
  16   echo "    start-cmd:   Generate docker command used to start container"
  17   echo
  18   echo "Options:"
  19   echo "    --skip-prereqs             Don't check launcher prerequisites"
  20   echo "    --docker-args              Extra arguments to pass when running docker"
  21   echo "    --skip-mac-address         Don't assign a mac address"
  22   echo "    --run-image                Override the image used for running the container"
  23   exit 1
  24 }
  25
  26 command=$1
  27 config=$2
  28 user_args=""
  29 user_run_image=""
  30
  31 if [[ $command == "run" ]]; then
  32   run_command=$3
  33 fi
  34
  35 while [ ${#} -gt 0 ]; do
  36   case "${1}" in
  37   --debug)
  38     DEBUG="1"
  39     ;;
  40   --skip-prereqs)
  41     SKIP_PREREQS="1"
  42     ;;
  43   --skip-mac-address)
  44     SKIP_MAC_ADDRESS="1"
  45     ;;
  46   --docker-args)
  47     user_args="$2"
  48     shift
  49     ;;
  50   --run-image)
  51     user_run_image="$2"
  52     shift
  53     ;;
  54   esac
  55
  56   shift 1
  57 done
  58
  59 if [ -z "$command" -o -z "$config" -a "$command" != "cleanup" ]; then
  60   usage
  61   exit 1
  62 fi
  63
  64 # Docker doesn't like uppercase characters, spaces or special characters, catch it now before we build everything out and then find out
  65 re='[[:upper:]/ !@#$%^&*()+~`=]'
  66 if [[ $config =~ $re ]];
  67   then
  68     echo
  69     echo "ERROR: Config name '$config' must not contain upper case characters, spaces or special characters. Correct config name and rerun $0."
  70     echo
  71     exit 1
  72 fi
  73
  74 cd "$(dirname "$0")"
  75
  76 docker_min_version='17.03.1'
  77 docker_rec_version='17.06.2'
  78 git_min_version='1.8.0'
  79 git_rec_version='1.8.0'
  80
  81 config_file=containers/"$config".yml
  82 cidbootstrap=cids/"$config"_bootstrap.cid
  83 local_discourse=local_discourse
  84 image=discourse/base:2.0.20190217
  85 docker_path=`which docker.io 2> /dev/null || which docker`
  86 git_path=`which git`
  87
  88 if [ "${SUPERVISED}" = "true" ]; then
  89   restart_policy="--restart=no"
  90   attach_on_start="-a"
  91   attach_on_run="-a stdout -a stderr"
  92 else
  93   attach_on_run="-d"
  94 fi
  95
  96 if [ -n "$DOCKER_HOST" ]; then
  97   docker_ip=`sed -e 's/^tcp:\/\/\(.*\):.*$/\1/' <<< "$DOCKER_HOST"`
  98 elif [ -x "$(which ip 2>/dev/null)" ]; then
  99   docker_ip=`ip addr show docker0 | \
 100                   grep 'inet ' | \
 101                   awk '{ split($2,a,"/"); print a[1] }';`
 102 else
 103   docker_ip=`ifconfig | \
 104                   grep -B1 "inet addr" | \
 105                   awk '{ if ( $1 == "inet" ) { print $2 } else if ( $2 == "Link" ) { printf "%s:" ,$1 } }' | \
 106                   grep docker0 | \
 107                   awk -F: '{ print $3 }';`
 108 fi
 109
 110 # From https://stackoverflow.com/a/44660519/702738
 111 compare_version() {
 112     if [[ $1 == $2 ]]; then
 113         return 1
 114     fi
 115     local IFS=.
 116     local i a=(${1%%[^0-9.]*}) b=(${2%%[^0-9.]*})
 117     local arem=${1#${1%%[^0-9.]*}} brem=${2#${2%%[^0-9.]*}}
 118     for ((i=0; i<${#a[@]} || i<${#b[@]}; i++)); do
 119         if ((10#${a[i]:-0} < 10#${b[i]:-0})); then
 120             return 1
 121         elif ((10#${a[i]:-0} > 10#${b[i]:-0})); then
 122             return 0
 123         fi
 124     done
 125     if [ "$arem" '<' "$brem" ]; then
 126         return 1
 127     elif [ "$arem" '>' "$brem" ]; then
 128         return 0
 129     fi
 130     return 1
 131 }
 132
 133
 134 install_docker() {
 135   echo "Docker is not installed, you will need to install Docker in order to run Launcher"
 136   echo "See https://docs.docker.com/installation/"
 137   exit 1
 138 }
 139
 140 check_prereqs() {
 141
 142   if [ -z $docker_path ]; then
 143     install_docker
 144   fi
 145
 146   # 1. docker daemon running?
 147   # we send stderr to /dev/null cause we don't care about warnings,
 148   # it usually complains about swap which does not matter
 149   test=`$docker_path info 2> /dev/null`
 150   if [[ $? -ne 0 ]] ; then
 151     echo "Cannot connect to the docker daemon - verify it is running and you have access"
 152     exit 1
 153   fi
 154
 155   # 2. running an approved storage driver?
 156   if ! $docker_path info 2> /dev/null | egrep -q '^Storage Driver: (aufs|btrfs|zfs|overlay|overlay2)$'; then
 157     echo "Your Docker installation is not using a supported storage driver.  If we were to proceed you may have a broken install."
 158     echo "aufs is the recommended storage driver, although zfs/btrfs/overlay and overlay2 may work as well."
 159     echo "Other storage drivers are known to be problematic."
 160     echo "You can tell what filesystem you are using by running \"docker info\" and looking at the 'Storage Driver' line."
 161     echo
 162     echo "If you wish to continue anyway using your existing unsupported storage driver,"
 163     echo "read the source code of launcher and figure out how to bypass this check."
 164     exit 1
 165   fi
 166
 167   # 3. running recommended docker version
 168   test=($($docker_path --version))  # Get docker version string
 169   test=${test[2]//,/}  # Get version alone and strip comma if exists
 170
 171   # At least minimum docker version
 172   if compare_version "${docker_min_version}" "${test}"; then
 173     echo "ERROR: Docker version ${test} not supported, please upgrade to at least ${docker_min_version}, or recommended ${docker_rec_version}"
 174     exit 1
 175   fi
 176
 177   # Recommend newer docker version
 178   if compare_version "${docker_rec_version}" "${test}"; then
 179     echo "WARNING: Docker version ${test} deprecated, recommend upgrade to ${docker_rec_version} or newer."
 180   fi
 181
 182   # 4. discourse docker image is downloaded
 183   test=`$docker_path images | awk '{print $1 ":" $2 }' | grep "$image"`
 184
 185   if [ -z "$test" ]; then
 186     echo
 187     echo "WARNING: We are about to start downloading the Discourse base image"
 188     echo "This process may take anywhere between a few minutes to an hour, depending on your network speed"
 189     echo
 190     echo "Please be patient"
 191     echo
 192   fi
 193
 194   # 5. running recommended git version
 195   test=($($git_path --version))  # Get git version string
 196   test=${test[2]//,/}  # Get version alone and strip comma if exists
 197
 198   # At least minimum version
 199   if compare_version "${git_min_version}" "${test}"; then
 200     echo "ERROR: Git version ${test} not supported, please upgrade to at least ${git_min_version}, or recommended ${git_rec_version}"
 201     exit 1
 202   fi
 203
 204   # Recommend best version
 205   if compare_version "${git_rec_version}" "${test}"; then
 206     echo "WARNING: Git version ${test} deprecated, recommend upgrade to ${git_rec_version} or newer."
 207   fi
 208
 209   # 6. able to attach stderr / out / tty
 210   test=`$docker_path run $user_args -i --rm -a stdout -a stderr $image echo working`
 211   if [[ "$test" =~ "working" ]] ; then : ; else
 212     echo "Your Docker installation is not working correctly"
 213     echo
 214     echo "See: https://meta.discourse.org/t/docker-error-on-bootstrap/13657/18?u=sam"
 215     exit 1
 216   fi
 217
 218   # 7. enough space for the bootstrap on docker folder
 219   folder=`$docker_path info --format '{{.DockerRootDir}}'`
 220   safe_folder=${folder:-/var/lib/docker}
 221   test=$(($(stat -f --format="%a*%S" $safe_folder)/1024**3 < 5))
 222   if [[ $test -ne 0 ]] ; then
 223     echo "You have less than 5GB of free space on the disk where $safe_folder is located. You will need more space to continue"
 224     df -h $safe_folder
 225     echo
 226     read -p "Would you like to attempt to recover space by cleaning docker images and containers in the system?(y/N)" -n 1 -r
 227     echo
 228     if [[ $REPLY =~ ^[Yy]$ ]]
 229     then
 230       $docker_path system prune -af
 231       echo "If the cleanup was successful, you may try again now"
 232     fi
 233     exit 1
 234   fi
 235 }
 236
 237
 238 if [ -z "$SKIP_PREREQS" ] && [ "$command" != "cleanup" ]; then
 239   check_prereqs
 240 fi
 241
 242 host_run() {
 243   read -r -d '' env_ruby << 'RUBY'
 244   require 'yaml'
 245
 246   input = STDIN.readlines.join
 247   yaml = YAML.load(input)
 248
 249   if host_run = yaml['host_run']
 250     params = yaml['params'] || {}
 251     host_run.each do |run|
 252       params.each do |k,v|
 253         run = run.gsub("$#{k}", v)
 254       end
 255       STDOUT.write "#{run}--SEP--"
 256     end
 257   end
 258 RUBY
 259
 260   host_run=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e "$env_ruby"`
 261
 262   while [ "$host_run" ] ; do
 263     iter=${host_run%%--SEP--*}
 264     echo
 265     echo "Host run: $iter"
 266     $iter || exit 1
 267     echo
 268     host_run="${host_run#*--SEP--}"
 269   done
 270 }
 271
 272
 273 set_volumes() {
 274   volumes=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
 275         "require 'yaml'; puts YAML.load(STDIN.readlines.join)['volumes'].map{|v| '-v ' << v['volume']['host'] << ':' << v['volume']['guest'] << ' '}.join"`
 276 }
 277
 278 set_links() {
 279     links=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
 280         "require 'yaml'; puts YAML.load(STDIN.readlines.join)['links'].map{|l| '--link ' << l['link']['name'] << ':' << l['link']['alias'] << ' '}.join"`
 281 }
 282
 283 find_templates() {
 284     local templates=`cat $1 | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
 285       "require 'yaml'; puts YAML.load(STDIN.readlines.join)['templates']"`
 286
 287     local arrTemplates=${templates// / }
 288
 289     if [ ! -z "$templates" ]; then
 290       for template in "${arrTemplates[@]}"
 291       do
 292         local nested_templates=$(find_templates $template)
 293
 294         if [ ! -z "$nested_templates" ]; then
 295           templates="$templates $nested_templates"
 296         fi
 297       done
 298
 299       echo $templates
 300     else
 301       echo ""
 302     fi
 303 }
 304
 305 set_template_info() {
 306     templates=$(find_templates $config_file)
 307
 308     arrTemplates=(${templates// / })
 309     config_data=$(cat $config_file)
 310
 311     input="hack: true"
 312
 313     for template in "${arrTemplates[@]}"
 314     do
 315       [ ! -z $template ] && {
 316         input="$input _FILE_SEPERATOR_ $(cat $template)"
 317       }
 318     done
 319
 320     # we always want our config file last so it takes priority
 321     input="$input _FILE_SEPERATOR_ $config_data"
 322
 323     read -r -d '' env_ruby << 'RUBY'
 324     require 'yaml'
 325
 326     input=STDIN.readlines.join
 327     # default to UTF-8 for the dbs sake
 328     env = {'LANG' => 'en_US.UTF-8'}
 329     input.split('_FILE_SEPERATOR_').each do |yml|
 330        yml.strip!
 331        begin
 332          env.merge!(YAML.load(yml)['env'] || {})
 333        rescue Psych::SyntaxError => e
 334         puts e
 335         puts "*ERROR."
 336        rescue => e
 337         puts yml
 338         p e
 339        end
 340     end
 341     puts env.map{|k,v| "-e\n#{k}=#{v}" }.join("\n")
 342 RUBY
 343
 344     tmp_input_file=$(mktemp)
 345
 346     echo "$input" > "$tmp_input_file"
 347     raw=`exec cat "$tmp_input_file" | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e "$env_ruby"`
 348
 349     rm -f "$tmp_input_file"
 350
 351     env=()
 352     ok=1
 353     while read i; do
 354       if [ "$i" == "*ERROR." ]; then
 355         ok=0
 356       elif [ -n "$i" ]; then
 357         env[${#env[@]}]="${i//\{\{config\}\}/${config}}"
 358       fi
 359     done <<< "$raw"
 360
 361     if [ "$ok" -ne 1 ]; then
 362       echo "${env[@]}"
 363       echo "YAML syntax error. Please check your containers/*.yml config files."
 364       exit 1
 365     fi
 366
 367     # labels
 368     read -r -d '' labels_ruby << 'RUBY'
 369     require 'yaml'
 370
 371     input=STDIN.readlines.join
 372     labels = {}
 373     input.split('_FILE_SEPERATOR_').each do |yml|
 374        yml.strip!
 375        begin
 376          labels.merge!(YAML.load(yml)['labels'] || {})
 377        rescue Psych::SyntaxError => e
 378         puts e
 379         puts "*ERROR."
 380        rescue => e
 381         puts yml
 382         p e
 383        end
 384     end
 385     puts labels.map{|k,v| "-l\n#{k}=#{v}" }.join("\n")
 386 RUBY
 387
 388     tmp_input_file=$(mktemp)
 389
 390     echo "$input" > "$tmp_input_file"
 391     raw=`exec cat "$tmp_input_file" | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e "$labels_ruby"`
 392
 393     rm -f "$tmp_input_file"
 394
 395     labels=()
 396     ok=1
 397     while read i; do
 398       if [ "$i" == "*ERROR." ]; then
 399         ok=0
 400       elif [ -n "$i" ]; then
 401         labels[${#labels[@]}]=$(echo $i | sed s/{{config}}/${config}/g)
 402       fi
 403     done <<< "$raw"
 404
 405     if [ "$ok" -ne 1 ]; then
 406       echo "${labels[@]}"
 407       echo "YAML syntax error. Please check your containers/*.yml config files."
 408       exit 1
 409     fi
 410
 411     # expose
 412     read -r -d '' ports_ruby << 'RUBY'
 413     require 'yaml'
 414
 415     input=STDIN.readlines.join
 416     ports = []
 417     input.split('_FILE_SEPERATOR_').each do |yml|
 418        yml.strip!
 419        begin
 420          ports += (YAML.load(yml)['expose'] || [])
 421        rescue Psych::SyntaxError => e
 422         puts e
 423         puts "*ERROR."
 424        rescue => e
 425         puts yml
 426         p e
 427        end
 428     end
 429     puts ports.map { |p| p.to_s.include?(':') ? "-p\n#{p}" : "--expose\n#{p}" }.join("\n")
 430 RUBY
 431
 432     tmp_input_file=$(mktemp)
 433
 434     echo "$input" > "$tmp_input_file"
 435     raw=`exec cat "$tmp_input_file" | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e "$ports_ruby"`
 436
 437     rm -f "$tmp_input_file"
 438
 439     ports=()
 440     ok=1
 441     while read i; do
 442       if [ "$i" == "*ERROR." ]; then
 443         ok=0
 444       elif [ -n "$i" ]; then
 445         ports[${#ports[@]}]=$i
 446       fi
 447     done <<< "$raw"
 448
 449     if [ "$ok" -ne 1 ]; then
 450       echo "${ports[@]}"
 451       echo "YAML syntax error. Please check your containers/*.yml config files."
 452       exit 1
 453     fi
 454
 455    merge_user_args
 456 }
 457
 458 if [ -z $docker_path ]; then
 459   install_docker
 460 fi
 461
 462 [ "$command" == "cleanup" ] && {
 463   $docker_path system prune -a
 464
 465   if [ -d /var/discourse/shared/standalone/postgres_data_old ]; then
 466     echo
 467     echo "Old PostgreSQL backup data cluster detected taking up $(du -hs /var/discourse/shared/standalone/postgres_data_old | awk '{print $1}') detected"
 468     read -p "Would you like to remove it? (Y/n): " -n 1 -r && echo
 469
 470     if [[ $REPLY =~ ^[Yy]$ ]]; then
 471       echo "removing old PostgreSQL data cluster at /var/discourse/shared/standalone/postgres_data_old..."
 472       rm -rf /var/discourse/shared/standalone/postgres_data_old
 473     else
 474       exit 1
 475     fi
 476   fi
 477
 478   exit 0
 479 }
 480
 481 if [ ! "$command" == "setup" ]; then
 482   if [[ ! -e $config_file ]]; then
 483     echo "Config file was not found, ensure $config_file exists"
 484     echo
 485     echo "Available configs ( `cd containers && ls -dm *.yml | tr -s '\n' ' ' | awk '{ gsub(/\.yml/, ""); print }'`)"
 486     exit 1
 487   fi
 488 fi
 489
 490 docker_version=($($docker_path --version))
 491 docker_version=${test[2]//,/}
 492 restart_policy=${restart_policy:---restart=always}
 493
 494 set_existing_container(){
 495   existing=`$docker_path ps -a | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
 496 }
 497
 498 run_stop() {
 499
 500   set_existing_container
 501
 502   if [ ! -z $existing ]
 503      then
 504        (
 505         set -x
 506         $docker_path stop -t 10 $config
 507        )
 508      else
 509        echo "$config was not started !"
 510        exit 1
 511   fi
 512 }
 513
 514 set_run_image() {
 515   run_image=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
 516     "require 'yaml'; puts YAML.load(STDIN.readlines.join)['run_image']"`
 517
 518   if [ -n "$user_run_image" ]; then
 519     run_image=$user_run_image
 520   elif [ -z "$run_image" ]; then
 521     run_image="$local_discourse/$config"
 522   fi
 523 }
 524
 525 set_boot_command() {
 526   boot_command=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
 527     "require 'yaml'; puts YAML.load(STDIN.readlines.join)['boot_command']"`
 528
 529   if [ -z "$boot_command" ]; then
 530
 531     no_boot_command=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
 532       "require 'yaml'; puts YAML.load(STDIN.readlines.join)['no_boot_command']"`
 533
 534     if [ -z "$no_boot_command" ]; then
 535       boot_command="/sbin/boot"
 536     fi
 537   fi
 538 }
 539
 540 merge_user_args() {
 541   local docker_args
 542
 543   docker_args=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
 544           "require 'yaml'; puts YAML.load(STDIN.readlines.join)['docker_args']"`
 545
 546   if [[ -n "$docker_args" ]]; then
 547     user_args="$user_args $docker_args"
 548   fi
 549 }
 550
 551 run_start() {
 552
 553    if [ -z "$START_CMD_ONLY" ]
 554    then
 555      existing=`$docker_path ps | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
 556      echo $existing
 557      if [ ! -z $existing ]
 558      then
 559        echo "Nothing to do, your container has already started!"
 560        exit 0
 561      fi
 562
 563      existing=`$docker_path ps -a | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
 564      if [ ! -z $existing ]
 565      then
 566        echo "starting up existing container"
 567        (
 568          set -x
 569          $docker_path start $config
 570        )
 571        exit 0
 572      fi
 573    fi
 574
 575    host_run
 576
 577    set_template_info
 578    set_volumes
 579    set_links
 580    set_run_image
 581    set_boot_command
 582
 583    # get hostname and settings from container configuration
 584    for envar in "${env[@]}"
 585    do
 586      if [[ $envar == DOCKER_USE_HOSTNAME* ]] || [[ $envar == DISCOURSE_HOSTNAME* ]]
 587      then
 588        # use as environment variable
 589        eval $envar
 590      fi
 591    done
 592
 593    (
 594      hostname=`hostname -s`
 595      # overwrite hostname
 596      if [ "$DOCKER_USE_HOSTNAME" = "true" ]
 597      then
 598        hostname=$DISCOURSE_HOSTNAME
 599      else
 600        hostname=$hostname-$config
 601      fi
 602
 603      # we got to normalize so we only have allowed strings, this is more comprehensive but lets see how bash does first
 604      # hostname=`$docker_path run $user_args --rm $image ruby -e 'print ARGV[0].gsub(/[^a-zA-Z-]/, "-")' $hostname`
 605      # docker added more hostname rules
 606      hostname=${hostname//_/-}
 607
 608
 609      if [ -z "$SKIP_MAC_ADDRESS" ] ; then
 610       mac_address="--mac-address $($docker_path run $user_args -i --rm -a stdout -a stderr $image /bin/sh -c "echo $hostname | md5sum | sed 's/^\(..\)\(..\)\(..\)\(..\)\(..\).*$/02:\1:\2:\3:\4:\5/'")"
 611      fi
 612
 613      if [ ! -z "$START_CMD_ONLY" ] ; then
 614        docker_path="true"
 615      fi
 616
 617      set -x
 618
 619      $docker_path run --shm-size=512m $links $attach_on_run $restart_policy "${env[@]}" "${labels[@]}" -h "$hostname" \
 620         -e DOCKER_HOST_IP="$docker_ip" --name $config -t "${ports[@]}" $volumes $mac_address $user_args \
 621         $run_image $boot_command
 622
 623    )
 624    exit 0
 625
 626 }
 627
 628 run_run() {
 629   set_template_info
 630   set_volumes
 631   set_links
 632   set_run_image
 633
 634   unset ERR
 635   (exec $docker_path run --rm --shm-size=512m $user_args $links "${env[@]}" -e DOCKER_HOST_IP="$docker_ip" -i -a stdin -a stdout -a stderr $volumes $run_image \
 636     /bin/bash -c "$run_command") || ERR=$?
 637
 638   if [[ $ERR > 0 ]]; then
 639     exit 1
 640   fi
 641 }
 642
 643 run_bootstrap() {
 644   host_run
 645
 646   # Is the image available?
 647   # If not, pull it here so the user is aware what's happening.
 648   $docker_path history $image >/dev/null 2>&1 || $docker_path pull $image
 649
 650   set_template_info
 651
 652   base_image=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
 653     "require 'yaml'; puts YAML.load(STDIN.readlines.join)['base_image']"`
 654
 655   update_pups=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
 656     "require 'yaml'; puts YAML.load(STDIN.readlines.join)['update_pups']"`
 657
 658   if [[ ! X"" = X"$base_image" ]]; then
 659     image=$base_image
 660   fi
 661
 662   set_volumes
 663   set_links
 664
 665   rm -f $cidbootstrap
 666
 667   run_command="cd /pups &&"
 668   if [[ ! "false" =  $update_pups ]]; then
 669     run_command="$run_command git pull &&"
 670   fi
 671   run_command="$run_command /pups/bin/pups --stdin"
 672
 673   echo $run_command
 674
 675   unset ERR
 676
 677   tmp_input_file=$(mktemp)
 678
 679   echo "$input" > "$tmp_input_file"
 680   (exec cat "$tmp_input_file" | $docker_path run --shm-size=512m $user_args $links "${env[@]}" -e DOCKER_HOST_IP="$docker_ip" --cidfile $cidbootstrap -i -a stdin -a stdout -a stderr $volumes $image \
 681     /bin/bash -c "$run_command") || ERR=$?
 682
 683   rm -f "$tmp_input_file"
 684
 685   unset FAILED
 686   # magic exit code that indicates a retry
 687   if [[ "$ERR" == 77 ]]; then
 688     $docker_path rm `cat $cidbootstrap`
 689     rm $cidbootstrap
 690     exit 77
 691   elif [[ "$ERR" > 0 ]]; then
 692     FAILED=TRUE
 693   fi
 694
 695   if [[ $FAILED = "TRUE" ]]; then
 696     if [[ ! -z "$DEBUG" ]]; then
 697       $docker_path commit `cat $cidbootstrap` $local_discourse/$config-debug || echo 'FAILED TO COMMIT'
 698       echo "** DEBUG ** Maintaining image for diagnostics $local_discourse/$config-debug"
 699     fi
 700
 701     $docker_path rm `cat $cidbootstrap`
 702     rm $cidbootstrap
 703     echo "** FAILED TO BOOTSTRAP ** please scroll up and look for earlier error messages, there may be more than one"
 704     exit 1
 705   fi
 706
 707   sleep 5
 708
 709   $docker_path commit `cat $cidbootstrap` $local_discourse/$config || echo 'FAILED TO COMMIT'
 710   $docker_path rm `cat $cidbootstrap` && rm $cidbootstrap
 711 }
 712
 713 case "$command" in
 714   bootstrap)
 715       run_bootstrap
 716       echo "Successfully bootstrapped, to startup use ./launcher start $config"
 717       exit 0
 718       ;;
 719
 720   run)
 721       run_run
 722       exit 0
 723       ;;
 724
 725   enter)
 726       exec $docker_path exec -it $config /bin/bash --login
 727       ;;
 728
 729   stop)
 730       run_stop
 731       exit 0
 732       ;;
 733
 734   logs)
 735
 736       $docker_path logs $config
 737       exit 0
 738       ;;
 739
 740   restart)
 741       run_stop
 742       run_start
 743       exit 0
 744       ;;
 745
 746   start-cmd)
 747     START_CMD_ONLY="1"
 748     run_start
 749     exit 0;
 750     ;;
 751
 752   start)
 753       run_start
 754       exit 0
 755       ;;
 756
 757   rebuild)
 758       if [ "$(git symbolic-ref --short HEAD)" == "master" ]; then
 759         echo "Ensuring launcher is up to date"
 760
 761         git remote update
 762
 763         LOCAL=$(git rev-parse @)
 764         REMOTE=$(git rev-parse @{u})
 765         BASE=$(git merge-base @ @{u})
 766
 767         if [ $LOCAL = $REMOTE ]; then
 768           echo "Launcher is up-to-date"
 769
 770         elif [ $LOCAL = $BASE ]; then
 771           echo "Updating Launcher"
 772           git pull || (echo 'failed to update' && exit 1)
 773
 774           for (( i=${#BASH_ARGV[@]}-1,j=0; i>=0,j<${#BASH_ARGV[@]}; i--,j++ ))
 775           do
 776             args[$j]=${BASH_ARGV[$i]}
 777           done
 778           exec /bin/bash $0 "${args[@]}" # $@ is empty, because of shift at the beginning. Use BASH_ARGV instead.
 779
 780         elif [ $REMOTE = $BASE ]; then
 781           echo "Your version of Launcher is ahead of origin"
 782
 783         else
 784           echo "Launcher has diverged source, this is only expected in Dev mode"
 785         fi
 786
 787       fi
 788
 789       set_existing_container
 790
 791       if [ ! -z $existing ]
 792         then
 793           echo "Stopping old container"
 794           (
 795             set -x
 796             $docker_path stop -t 10 $config
 797           )
 798       fi
 799
 800       run_bootstrap
 801
 802       if [ ! -z $existing ]
 803         then
 804           echo "Removing old container"
 805           (
 806             set -x
 807             $docker_path rm $config
 808           )
 809       fi
 810
 811       run_start
 812       exit 0
 813       ;;
 814
 815
 816   destroy)
 817       (set -x; $docker_path stop -t 10 $config && $docker_path rm $config) || (echo "$config was not found" && exit 0)
 818       exit 0
 819       ;;
 820 esac
 821
 822 usage