docker-entrypoint

#!/usr/bin/env bash

set -e

domain_from_route() {
  echo $1 | grep -Po '(?<=\.)(.+)$'
}

hostname_from_route() {
  echo $1 | grep -Po '^([^.]+)'
}

app_guid() {
  cf app $1 --guid | head -1
}

app_process_guid() {
  cf curl /v3/apps/$1/processes | jq -Mr '.resources[0].guid'
}

count_running_instances() {
  cf curl /v3/processes/$1/stats | jq -Mr '[.resources[] | select(.state=="RUNNING")] | length'
}

login() {
  # Login
  echo
  cf api ${CF_API}
  cf auth # Uses CF_USERNAME and CF_PASSWORD env vars
  cf target -o ${CF_ORG} -s ${CF_SPACE}
}

run_hook() {
  hook_path=/hooks/$1
  if [ -f "${hook_path}" ]; then
    echo
    echo "Running hook $1"
    echo
    ${hook_path} "${@:2}"
  fi
}

wait_for_running_instances() {
  new_app_name=$1
  instance_count=$2

  new_app_guid=$(app_guid ${new_app_name})
  new_app_process_guid=$(app_process_guid ${new_app_guid})

  startup_timeout=${CF_STARTUP_TIMEOUT}
  startup_interval=3

  echo
  echo "Allowing ${startup_timeout}s for ${instance_count} RUNNING instances..."

  new_app_running_instances=$(count_running_instances ${new_app_process_guid})

  startup_start=$(date +%s)
  while [ ${new_app_running_instances} -lt ${instance_count} ]; do
    startup_elapsed=$(($(date +%s) - ${startup_start}))
    if [ ${startup_elapsed} -ge ${startup_timeout} ]; then
      echo
      echo "ERROR: Failed to start ${instance_count} RUNNING instances in ${startup_timeout}s"
      exit 1
    fi
    echo "${new_app_running_instances}/${instance_count}..."
    sleep ${startup_interval} && startup_timer=$((${startup_timer} + ${startup_interval}))
    new_app_running_instances=$(count_running_instances ${new_app_process_guid})
  done
  echo "${new_app_running_instances}/${instance_count}..."
  echo "OK"
}

deploy() {
  push_args="$@"
  echo "push_args=$push_args"

  run_hook "pre-login"
  login
  run_hook "post-login"

  # Get the primary route from the first in CF_ROUTES
  routes=(${CF_ROUTES})
  primary_route=${routes[0]}
  echo "Primary route: ${primary_route}"

  primary_route_domain=$(domain_from_route ${primary_route})
  primary_route_hostname=$(hostname_from_route ${primary_route})

  # Get the GUID of the domain
  domain_guid=$(cf curl "/v3/domains?names=${primary_route_domain}" | jq -Mr .resources[0].guid)

  # Get the GUID of the app with the hostname + domain route mapped to it
  old_app_guid=$(cf curl "/v3/routes?domain_guids=${domain_guid}&hosts=${primary_route_hostname}" | jq -Mr .resources[0].destinations[0].app.guid)

  if [ "${old_app_guid}" = "null" ]; then
    echo "No old mirror: assuming first push."
    new_mirror="blue"
    old_mirror="null"
    old_app_name="null"
  else
    # Get the name of the live, i.e. old, app
    old_app_name=$(cf curl "/v3/apps/${old_app_guid}" | jq -Mr .name)

    if [ "${old_app_name}" = "${CF_APP_NAME}-blue" ]; then
      old_mirror="blue"
      new_mirror="green"
    elif [ "${old_app_name}" = "${CF_APP_NAME}-green" ]; then
      old_mirror="green"
      new_mirror="blue"
    else
      echo "Unknown old mirror: ${old_app_name}"
      exit 1
    fi
  fi

  new_app_name=${CF_APP_NAME}-${new_mirror}

  echo
  echo "Old mirror:    ${old_mirror}"
  echo "New mirror:    ${new_mirror}"

  cf create-app ${new_app_name} --app-type ${CF_APP_TYPE}

  if [ "${CF_AUTOSCALING}" == "true" ]; then
    # Prevent pre-existing autoscaling from interfering with the initial scaling up
    echo
    echo "Detaching autoscaling policy"
    cf detach-autoscaling-policy ${new_app_name}

    autoscaling_policy_file="/autoscaling-policy.json"
  fi

  if [ "${old_app_name}" = "null" ]; then
    instance_count=1
  else
    # If no autoscaling policy supplied, copy from old mirror
    if [ "${CF_AUTOSCALING}" == "true" ]; then
      if [ ! -f ${autoscaling_policy_file} ]; then
        echo
        echo "Copying autoscaling policy from ${old_app_name}"
        set +e
        cf autoscaling-policy ${old_app_name} | tail -n +2 > ${autoscaling_policy_file}
        set -e
      fi
    fi

    old_app_process_guid=$(app_process_guid ${old_app_guid})
    instance_count=$(count_running_instances ${old_app_process_guid})
  fi

  # Adjust instance count based on autoscaling policy
  if [ "${CF_AUTOSCALING}" == "true" ]; then
    if [ -f ${autoscaling_policy_file} ]; then
      autoscaling_policy_min_count=$(cat ${autoscaling_policy_file} | jq -Mr .instance_min_count)
      autoscaling_policy_max_count=$(cat ${autoscaling_policy_file} | jq -Mr .instance_max_count)
      if [ ${autoscaling_policy_min_count} -gt ${instance_count} ]; then
        instance_count=${autoscaling_policy_min_count}
      fi
      if [ ${autoscaling_policy_max_count} -lt ${instance_count} ]; then
        instance_count=${autoscaling_policy_max_count}
      fi
    fi
  fi

  # Push & scale
  run_hook "pre-push" ${old_app_name} ${new_app_name}
  cf push ${new_app_name} --instances ${instance_count} ${push_args}

  if [ "${CF_AUTOSCALING}" == "true" ]; then
    wait_for_running_instances ${new_app_name} ${instance_count}
    if [ -f ${autoscaling_policy_file} ]; then
      echo
      echo "Attaching autoscaling policy"
      cf attach-autoscaling-policy ${new_app_name} ${autoscaling_policy_file}
    fi
  fi

  run_hook "post-push" ${old_app_name} ${new_app_name}

  # Map routes
  for route in ${CF_ROUTES}; do
    echo
    echo "Remapping ${route}"
    route_domain=$(domain_from_route ${route})
    route_hostname=$(hostname_from_route ${route})

    cf map-route ${new_app_name} ${route_domain} -n ${route_hostname}
    if [ "${old_mirror}" != "null" ]; then
      cf unmap-route ${old_app_name} ${route_domain} -n ${route_hostname}
    fi
  done

  run_hook "post-routing" ${old_app_name} ${new_app_name}

  if [ "${old_mirror}" != "null" ]; then
    cf stop ${old_app_name}
  fi

  run_hook "post-deploy" ${old_app_name} ${new_app_name}

  echo
  echo "Blue-green deployment done."
}

if [ "$1" == "deploy" ]; then
  # Default command performs blue-green deployment, with additional args following
  deploy "${@:2}"
else
  # Otherwise run whatever was in the command
  exec "$@"
fi