start

#!/bin/bash
set -e
source scripts/common.sh
source scripts/common-kubectl.sh

function display_usage_and_exit {
  bold "Welcome to the all in one GCP Kubernetes GoCD deployment script."
  echo ""
  echo "Usage: $(basename "$0") <command> [options]"
  echo ""
  bold "Terraform commands:"
  echo " - plan            [module]                        Perform a terraform plan"
  echo " - apply-plan      [module]                        Apply a terraform plan"
  echo " - destroy         [module] [terraform options]    Destroy one of these, (please be aware of dependencies)"
  echo ""
  echo "   Available modules: $(ls terraform | tr -s "\n" " ")"
  echo ""
  bold "Application commands:"
  echo " - configure       [preprod | prod]                Configure an empty kubernetes cluster with basic config"
  echo " - deploy          [gocd-master | gocd-agents]     Deploy either the go master or agents"
  echo ""
  bold "Utility commands:"
  echo " - bootstrap                                       Does all of the above, on a new GCP project"
  echo " - nuke                                            Destroy everything in one devastating blow"
  echo " - clean                                           Cleans up orphaned firewall rules, disks etc"
  echo ""
  exit 1
}

function ensure_linux {
  OS=$(uname -a | awk '{print $1}')
  if [ ! "$OS" = "Linux" ]; then
    bold "Sorry, you're not supported!"
    echo ""
    echo "This script was designed to be run on Linux, not $OS"
    echo "There will be differences in the tools which have no been accounted for"
    echo ""
    echo "Please try using the docker version instead!"
    echo "docker run --rm -it stono/ciinabox"
    echo ""
    echo "Thanks!"
    exit 1
  fi
}

function ensure_tools {
  bold "Checking tool dependencies..."
  command_check "kubectl"
  command_check "terraform"
  command_check "gcloud"
  command_check "gsutil"
  command_check "gpg2"
  command_check "curl"
  command_check "pdata" "You can install it with 'npm install -g peopledata-cli'"

  EXPECTED_TERRAFORM=0.8.7
  EXPECTED_KUBECTL=1.5.3

  echo ""
  bold "Checking tool versions..."
  ACTUAL_TERRAFORM=$(terraform --version | head -n 1 | awk '{print $2}' | cut -c2-)
  ACTUAL_KUBECTL=$(kubectl version --client --short | awk '{print $3}' | cut -c2-)

  version_check "$ACTUAL_KUBECTL" "$EXPECTED_KUBECTL" "kubectl"
  version_check "$ACTUAL_TERRAFORM" "$EXPECTED_TERRAFORM" "terraform"
  echo ""
}

function ensure_environment_variables {
  bold "Checking environment configuration..."
  enforce_arg "LETSENCRYPT_EMAIL" "Lets Encrypt email address"

  enforce_arg "STACK_NAME" "This application stack name"
  enforce_arg "STATE_BUCKET" "GCS Bucket to store state in"
  enforce_arg "NETWORK_NAME" "GCP Private Network Name"
  enforce_arg "GCP_PROJECT_NAME" "GCP Project Name"
  enforce_arg "PREPROD_CLUSTER_PASSWORD" "The Kubernetes preprod cluster password"
  enforce_arg "PROD_CLUSTER_PASSWORD" "The Kubernetes prod cluster password"
  enforce_arg "TARGET_REGION" "The primary region"
  enforce_arg "TARGET_ZONE_A" "HA Zone 1"
  enforce_arg "TARGET_ZONE_B" "HA Zone 2"

  enforce_arg "GOCD_USERNAME" "Username to login to GOCD with"
  enforce_arg "GOCD_PASSWORD" "Password to login to GOCD with"
  enforce_arg "GOCD_AGENT_KEY" "Secure key that agents connect with"

  echo ""
}

function ensure_cluster_doesnt_exist {
  bold "Checking for cluster..." 
  if gcloud compute instances list | grep "-$env-" &>/dev/null; then
    echo "Error!  There appears to be machines associated with $env."
    echo "This means you're trying to build a cluster when one is already built"
    echo "You're a silly monkey.  Destroy it first" 
    exit 1
  else
    echo " + Cluster does not exist."
  fi
  echo ""
}

function ensure_gpg_key {
  export GNUPGHOME="$PWD/.tmp/.gnupg"
  if [ -f "$GNUPGHOME/agent.asc" ]; then
    echo "agent.asc already exists"
    return;
  else
    bold "Generating GPG key..."
    mkdir -p "$GNUPGHOME"
    chmod 0700 "$GNUPGHOME"
  fi

  cat > "$GNUPGHOME/agent" <<EOF
  %echo Generating a basic OpenPGP key
  Key-Type: DSA
  Key-Length: 1024
  Subkey-Type: ELG-E
  Subkey-Length: 1024
  Name-Real: GoCCD 
  Name-Comment: GoCD Agent GPG Key 
  Name-Email: gocd-agent@noreply.com 
  Expire-Date: 0
  %no-protection
  %no-ask-passphrase
  %commit
  %echo done
EOF

gpg2 --batch --gen-key "$GNUPGHOME/agent"
gpg2 -a --export > "$GNUPGHOME/agent.asc"
gpg2 -a --export-secret-keys >> "$GNUPGHOME/agent.asc"
}

function ensure_ssh_key {
  if [ ! -d "./.tmp/.ssh" ]; then
    bold "Generating SSH key pair..."
    mkdir -p ./.tmp/.ssh
    ssh-keygen -b 2048 -t rsa -f "$PWD/.tmp/.ssh/id_rsa" -q -N ""
  fi
}

function ensure_in_docker {
  if [ ! -f "/.dockerenv" ]; then
    bold "You are not running inside docker!  I really think you should."
    confirm
  fi
  echo ""
}

function deploy_gocd_master {
  bold "Deploying gocd secrets..."
  echo -n $(htpasswd -nb -s $GOCD_USERNAME $GOCD_PASSWORD | xargs) > ./.tmp/users
  ensure_secret_file "gocd.users" "users" "./.tmp/users"
  ensure_secret_literal "gocd.goagent-key" "key" "$GOCD_AGENT_KEY"

  ensure_ssh_key  
  delete_secret "gocd.ssh"
  kube create secret generic "gocd.ssh" --from-file=ssh-privatekey=.tmp/.ssh/id_rsa --from-file=ssh-publickey=.tmp/.ssh/id_rsa.pub

  echo ""
  bold "Deploying gocd master..."
  pdata app deploy "$ROOT/kubernetes/master.pod.yml"

  echo ""
  bold "Deploying gocd master service..."
  pdata app deploy "$ROOT/kubernetes/master.service.yml"

  echo ""
  bold "Deploying gocd NGINX..."
  pdata app deploy "$ROOT/kubernetes/nginx.pod.yml"

  echo ""
  export GOCD_MASTER_IP=$(gcloud compute addresses describe $STACK_NAME-gocd | grep "address:" | awk '{print $2}' | xargs)
  bold "Deploying gocd NGINX service with static ip: $GOCD_MASTER_IP..."
  pdata app deploy "$ROOT/kubernetes/nginx.service.yml"

  echo ""
  GOCD_URL="https://$GOCD_MASTER_IP/go"
  wait_for_url "$GOCD_URL"
  bold "GoCD is online at: $GOCD_URL!"
}

function deploy_gocd_agent {
  echo "Ensuring GPG key..."
  ensure_gpg_key
  ensure_secret_file "goagent.gpg-key" "agent.asc" "./.tmp/.gnupg/agent.asc"

  echo ""
  bold "Deploying gocd preprod agents..."
  export GOCD_AGENT_ENV=preprod
  export AGENT_ADDITIONAL_ENV=",integration,infrastructure"
  pdata app deploy "$ROOT/kubernetes/agent.pod.yml"

  echo ""
  bold "Deploying gocd prod agents..."
  export GOCD_AGENT_ENV=prod
  export AGENT_ADDITIONAL_ENV=",infrastructure"
  pdata app deploy "$ROOT/kubernetes/agent.pod.yml"

  echo ""
  bold "GoCD agents deployed!"
}

function plan_build {
  bold "Planning the build..."
  $ROOT/scripts/infra plan "$1"
}

function plan_destroy {
  bold "Planning the destruction..."
  $ROOT/scripts/infra plan_destroy $* 
}

function terraform_apply {
  bold "Applying terraform plan..."
  $ROOT/scripts/infra apply "$1"
}

function do_kube_environment {
  check_presence "$env"
  bold Configuring env...
  $ROOT/scripts/configure-env "$*"
}

function do_infra {
  env=$1
  check_presence "$env"
  plan_build "$env"
  confirm
  terraform_apply "$env"
  if [ "$env" = "preprod" ] || [ "$env" = "prod" ]; then
    do_kube_environment "$env"
  fi
}

function do_deploy {
  app=$1
  check_presence "$app"
  acquire_credentials_for_cluster "${STACK_NAME}-preprod"
  if [ "$app" = "gocd-master" ]; then
    deploy_gocd_master  
  elif [ "$app" = "gocd-agents" ]; then
    deploy_gocd_agent
  else
    display_usage_and_exit  
  fi
}

function do_kube_destroy {
  env=$1
  check_presence "$env"
  set +e
  acquire_credentials_for_cluster "${STACK_NAME}-${env}"
  if [ ! "$?" = "0" ]; then
    echo " - Unable to get cluster credentials"
  else
    set -e
    echo "Deleting all namespaces and resources in ${STACK_NAME}-${env}"
    for ns in $(kubectl get namespaces --no-headers | awk '{print $1}'); do
      if [ ! "$ns" = "kube-system" ]; then
        kube --namespace="$ns" delete ingress --all --cascade=true --now
        kube --namespace="$ns" delete services --all --cascade=true --now
        kube --namespace="$ns" delete statefulsets --all --cascade=true --now
        kube --namespace="$ns" delete deployments --all --cascade=true --now
      fi
    done
  fi
}

function do_infra_destroy {
  env=$1
  check_presence $env
  plan_destroy $*
  confirm
  terraform_apply "$env"
}

function do_infra_cleanup {
  ./scripts/cleanup-networking
  ./scripts/cleanup-disks
}

command="${1:-}"
env="${2:-}"
args="${@:3}"

export KUBECTL_NAMESPACE=default
mkdir -p .tmp

ensure_linux
ensure_in_docker
ensure_tools
ensure_environment_variables
ensure_gcloud_configuration

case "$command" in
  plan)
    plan_build "$env"
    exit 0
    ;;
  apply-plan)
    terraform_apply "$env"    
    ;;
  deploy)
    do_deploy "$env"
    exit 0
    ;;
  destroy)
    if [ "$env" = "preprod" ] || [ "$env" = "prod" ]; then
      do_kube_destroy "$env"
    fi
    do_infra_destroy "$env" "$args"
    do_infra_cleanup
    exit 0
    ;;
  clean) 
    do_infra_cleanup
    exit 0
    ;;
  configure)
    if [ "$env" = "preprod" ] || [ "$env" = "prod" ]; then
      do_kube_environment "$env"
    fi
    exit 0
    ;;
  bootstrap)
    ensure_cluster_doesnt_exist
    do_infra "gocd"
    do_infra "networking"
    do_infra "preprod"
    do_infra "prod"
    do_deploy "gocd-master"
    do_deploy "gocd-agents"
    echo ""
    bold "Bootstrap complete, have fun on GoCD at $GOCD_URL"
    exit 0
    ;;
  nuke)
    do_kube_destroy "prod"
    do_kube_destroy "preprod"
    do_infra_destroy "prod"
    do_infra_destroy "preprod"
    do_infra_cleanup
    do_infra_destroy "networking"
    # do_infra_destroy "gocd"
    echo "[gocd] has been excluded, as this contains your gocd config"
    echo "in order to delete that, manually run destroy gocd"
    echo ""
    bold "Nuke complete."
    exit 0
    ;;
  *)
    display_usage_and_exit
    ;;
esac

exit 0