#!/bin/bash

################################################################################
# This script designed to provide a complete one-touch install of Chef-BCPC in
# an environment with a proxy and custom DNS servers; VMs booted headlessly
# simple few environment variables to tune booting for fast testing of Chef-BCPC
# Run this script in the root of the git repository
#

set -e

if [[ "$(pwd)" != "$(git rev-parse --show-toplevel)" ]] {
  printf '#### WARNING: This should be run in the git top level directory! ####\n' > /dev/stderr
}

global ENVIRONMENT := 'Test-Laptop'
global PROXY := 'proxy.example.com:80'
global DNS_SERVERS := ''"8.8.8.8", "8.8.4.4"''
export BOOTSTRAP_VM_MEM=3096
export BOOTSTRAP_VM_CPUs=2
export CLUSTER_VM_MEM=5120
export CLUSTER_VM_CPUs=4

printf "#### Setup configuration files\n"
# setup vagrant
sed -i 's/vb.gui = true/vb.gui = false/' Vagrantfile

# setup proxy_setup.sh
sed -i "s/#export PROXY=.*\"/export PROXY=\"$PROXY\"/" proxy_setup.sh

# setup environment file
sed -i "s/\"dns_servers\" : \[ \"8.8.8.8\", \"8.8.4.4\" \]/\"dns_servers\" : \[ $DNS_SERVERS \]/" environments/$(ENVIRONMENT).json
sed -i "s#\(\"bootstrap\": {\)#\1\n\"proxy\" : \"http://$PROXY\",\n#" environments/$(ENVIRONMENT).json

printf "#### Setup VB's and Bootstrap\n"
source ./vbox_create.sh

download_VM_files || shell { echo "############## VBOX DOWNLOAD VM FILES RETURNED $Status ##############" && exit 1 }
create_bootstrap_VM || shell { echo "############## VBOX CREATE BOOTSTRAP VM RETURNED $Status ##############" && exit 1 }
create_cluster_VMs || shell { echo "############## VBOX CREATE CLUSTER VMs RETURNED $Status ##############" && exit 1 }
install_cluster || shell { echo "############## bootstrap_chef.sh returned $Status ##############" && exit 1 }

printf "#### Cobbler Boot\n"
printf "Snapshotting pre-Cobbler and booting (unless already running)\n"
global vms_started := '"False'"
for i in [1 2 3] {
  vboxmanage showvminfo bcpc-vm$i | grep -q '^State:.*running' || global vms_started := '"True'"
  vboxmanage showvminfo bcpc-vm$i | grep -q '^State:.*running' || VBoxManage snapshot bcpc-vm$i take Shoe-less
  vboxmanage showvminfo bcpc-vm$i | grep -q '^State:.*running' || VBoxManage startvm bcpc-vm$i --type headless
}

printf "Checking VMs are up: \n"
while ! nc -w 1 -q 0 10.0.100.11 22 || \
         !  nc -w 1 -q 0 10.0.100.12 22 || \
         !  nc -w 1 -q 0 10.0.100.13 22
{
  sleep 60
  printf "Hosts down: "
  for m in [11 12 13] {
    nc -w 1 -q 0 10.0.100.$m 22 > /dev/null || echo -n "10.0.100.$m "
  }
  printf "\n"
}

printf "Snapshotting post-Cobbler\n"
[[ "$vms_started" == "True" ]] && VBoxManage snapshot bcpc-vm1 take Post-Cobble
[[ "$vms_started" == "True" ]] && VBoxManage snapshot bcpc-vm2 take Post-Cobble
[[ "$vms_started" == "True" ]] && VBoxManage snapshot bcpc-vm3 take Post-Cobble

printf "#### Chef all the nodes\n"
vagrant ssh -c "sudo apt-get install -y sshpass"

global cobbler_pass := $[vagrant ssh -c "cd chef-bcpc; knife data bag show configs $ENVIRONMENT | grep 'cobbler-root-password:'|sed 's/.* //']

printf "#### Chef the first headnode(s)\n"
if ! vagrant ssh -c "cd chef-bcpc; ./cluster-assign-roles.sh $ENVIRONMENT bcpc-vm1" { 
  printf "## set the first machine to admin\n"
  vagrant ssh -c 'cd chef-bcpc; echo -e "/\"admin\": false\ns/false/true\nw\nq\n" | EDITOR=ed knife client edit `knife client list | grep bcpc-vm1`'
  # re-run chef
  vagrant ssh -c "cd chef-bcpc; echo $cobbler_pass | sudo knife bootstrap -E $ENVIRONMENT -r 'role[BCPC-Headnode]' 10.0.100.11 -x ubuntu --sudo"
}

for i in [2 3] {
  printf "## Machine bcpc-vm$(i)\n"
  vagrant ssh -c "cd chef-bcpc; ./cluster-assign-roles.sh $ENVIRONMENT bcpc-vm$i"
}

printf "Snapshotting post-Cobbler\n"
VBoxManage snapshot bcpc-vm1 take Full-Shoes
VBoxManage snapshot bcpc-vm2 take Full-Shoes
VBoxManage snapshot bcpc-vm3 take Full-Shoes
(CommandList
  children: [
    (C {(set)} {(-e)})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_GlobNEqual
                      left: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: (CommandList children:[(C {(pwd)})])
                              left_token: <Left_CommandSub "$(">
                              spids: [33 35]
                            )
                          )
                        }
                      right: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [(C {(git)} {(rev-parse)} {(--show-toplevel)})]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [41 47]
                            )
                          )
                        }
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [
                {(printf)}
                {(SQ <"#### WARNING: This should be run in the git top level directory! ####\\n">)}
              ]
              redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/stderr)} spids:[62])]
            )
          ]
          spids: [-1 53]
        )
      ]
      spids: [-1 66]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:ENVIRONMENT) op:Equal rhs:{(Test-Laptop)} spids:[69])]
      spids: [69]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PROXY)
          op: Equal
          rhs: {(proxy.example.com) (Lit_Other ":") (80)}
          spids: [72]
        )
      ]
      spids: [72]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:DNS_SERVERS)
          op: Equal
          rhs: {(SQ <"\"8.8.8.8\", \"8.8.4.4\"">)}
          spids: [77]
        )
      ]
      spids: [77]
    )
    (C {(export)} {(Lit_VarLike "BOOTSTRAP_VM_MEM=") (3096)})
    (C {(export)} {(Lit_VarLike "BOOTSTRAP_VM_CPUs=") (2)})
    (C {(export)} {(Lit_VarLike "CLUSTER_VM_MEM=") (5120)})
    (C {(export)} {(Lit_VarLike "CLUSTER_VM_CPUs=") (4)})
    (C {(printf)} 
      {(DQ ("#### Setup configuration files") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))}
    )
    (C {(sed)} {(-i)} {(SQ <"s/vb.gui = true/vb.gui = false/">)} {(Vagrantfile)})
    (C {(sed)} {(-i)} 
      {
        (DQ ("s/#export PROXY=.*") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
          ("/export PROXY=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$PROXY") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (/)
        )
      } {(proxy_setup.sh)}
    )
    (C {(sed)} {(-i)} 
      {
        (DQ (s/) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (dns_servers) 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" : ") (EscapedLiteralPart token:<Lit_EscapedChar "\\[">) (" ") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (8.8.8.8) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (", ") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (8.8.4.4) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\]">) (/) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (dns_servers) 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" : ") (EscapedLiteralPart token:<Lit_EscapedChar "\\[">) (" ") ($ VSub_Name "$DNS_SERVERS") (" ") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\]">) (/)
        )
      } {(environments/) (${ VSub_Name ENVIRONMENT) (.json)}
    )
    (C {(sed)} {(-i)} 
      {
        (DQ ("s#") (EscapedLiteralPart token:<Lit_EscapedChar "\\(">) 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (bootstrap) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (": {") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) ("#") (EscapedLiteralPart token:<Lit_EscapedChar "\\1">) 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\n">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (proxy) 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" : ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("http://") ($ VSub_Name "$PROXY") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (",") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">) ("#")
        )
      } {(environments/) (${ VSub_Name ENVIRONMENT) (.json)}
    )
    (C {(printf)} 
      {(DQ ("#### Setup VB's and Bootstrap") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))}
    )
    (C {(source)} {(./vbox_create.sh)})
    (AndOr
      children: [
        (C {(download_VM_files)})
        (Subshell
          child: 
            (AndOr
              children: [
                (C {(echo)} 
                  {
                    (DQ ("############## VBOX DOWNLOAD VM FILES RETURNED ") ($ VSub_QMark "$?") 
                      (" ##############")
                    )
                  }
                )
                (C {(exit)} {(1)})
              ]
              op_id: Op_DAmp
            )
          spids: [238 254]
        )
      ]
      op_id: Op_DPipe
    )
    (AndOr
      children: [
        (C {(create_bootstrap_VM)})
        (Subshell
          child: 
            (AndOr
              children: [
                (C {(echo)} 
                  {
                    (DQ ("############## VBOX CREATE BOOTSTRAP VM RETURNED ") ($ VSub_QMark "$?") 
                      (" ##############")
                    )
                  }
                )
                (C {(exit)} {(1)})
              ]
              op_id: Op_DAmp
            )
          spids: [260 276]
        )
      ]
      op_id: Op_DPipe
    )
    (AndOr
      children: [
        (C {(create_cluster_VMs)})
        (Subshell
          child: 
            (AndOr
              children: [
                (C {(echo)} 
                  {
                    (DQ ("############## VBOX CREATE CLUSTER VMs RETURNED ") ($ VSub_QMark "$?") 
                      (" ##############")
                    )
                  }
                )
                (C {(exit)} {(1)})
              ]
              op_id: Op_DAmp
            )
          spids: [282 298]
        )
      ]
      op_id: Op_DPipe
    )
    (AndOr
      children: [
        (C {(install_cluster)})
        (Subshell
          child: 
            (AndOr
              children: [
                (C {(echo)} 
                  {
                    (DQ ("############## bootstrap_chef.sh returned ") ($ VSub_QMark "$?") 
                      (" ##############")
                    )
                  }
                )
                (C {(exit)} {(1)})
              ]
              op_id: Op_DAmp
            )
          spids: [304 320]
        )
      ]
      op_id: Op_DPipe
    )
    (C {(printf)} {(DQ ("#### Cobbler Boot") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))})
    (C {(printf)} 
      {
        (DQ ("Snapshotting pre-Cobbler and booting (unless already running)") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:vms_started) op:Equal rhs:{(DQ (False))} spids:[337])]
      spids: [337]
    )
    (ForEach
      iter_name: i
      iter_words: [{(1)} {(2)} {(3)}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (AndOr
              children: [
                (Pipeline
                  children: [
                    (C {(vboxmanage)} {(showvminfo)} {(bcpc-vm) ($ VSub_Name "$i")})
                    (C {(grep)} {(-q)} {(SQ <"^State:.*running">)})
                  ]
                  negated: False
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:vms_started)
                      op: Equal
                      rhs: {(DQ (True))}
                      spids: [377]
                    )
                  ]
                  spids: [377]
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (Pipeline
                  children: [
                    (C {(vboxmanage)} {(showvminfo)} {(bcpc-vm) ($ VSub_Name "$i")})
                    (C {(grep)} {(-q)} {(SQ <"^State:.*running">)})
                  ]
                  negated: False
                )
                (C {(VBoxManage)} {(snapshot)} {(bcpc-vm) ($ VSub_Name "$i")} {(take)} {(Shoe-less)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (Pipeline
                  children: [
                    (C {(vboxmanage)} {(showvminfo)} {(bcpc-vm) ($ VSub_Name "$i")})
                    (C {(grep)} {(-q)} {(SQ <"^State:.*running">)})
                  ]
                  negated: False
                )
                (C {(VBoxManage)} {(startvm)} {(bcpc-vm) ($ VSub_Name "$i")} {(--type)} {(headless)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [355 444]
        )
      spids: [347 353]
    )
    (C {(printf)} {(DQ ("Checking VMs are up: ") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))})
    (While
      cond: [
        (AndOr
          children: [
            (Pipeline
              children: [(C {(nc)} {(-w)} {(1)} {(-q)} {(0)} {(10.0.100.11)} {(22)})]
              negated: True
            )
            (AndOr
              children: [
                (Pipeline
                  children: [(C {(nc)} {(-w)} {(1)} {(-q)} {(0)} {(10.0.100.12)} {(22)})]
                  negated: True
                )
                (Pipeline
                  children: [(C {(nc)} {(-w)} {(1)} {(-q)} {(0)} {(10.0.100.13)} {(22)})]
                  negated: True
                )
              ]
              op_id: Op_DPipe
            )
          ]
          op_id: Op_DPipe
        )
      ]
      body: 
        (DoGroup
          children: [
            (C {(sleep)} {(60)})
            (C {(printf)} {(DQ ("Hosts down: "))})
            (ForEach
              iter_name: m
              iter_words: [{(11)} {(12)} {(13)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(nc)} {(-w)} {(1)} {(-q)} {(0)} {(10.0.100.) ($ VSub_Name "$m")} {(22)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(/dev/null)}
                              spids: [558]
                            )
                          ]
                        )
                        (C {(echo)} {(-n)} {(DQ (10.0.100.) ($ VSub_Name "$m") (" "))})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [540 575]
                )
              spids: [532 538]
            )
            (C {(printf)} {(DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))})
          ]
          spids: [512 584]
        )
    )
    (C {(printf)} {(DQ ("Snapshotting post-Cobbler") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))})
    (AndOr
      children: [
        (DBracket
          expr: 
            (BoolBinary
              op_id: BoolBinary_GlobDEqual
              left: {(DQ ($ VSub_Name "$vms_started"))}
              right: {(DQ (True))}
            )
        )
        (C {(VBoxManage)} {(snapshot)} {(bcpc-vm1)} {(take)} {(Post-Cobble)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (DBracket
          expr: 
            (BoolBinary
              op_id: BoolBinary_GlobDEqual
              left: {(DQ ($ VSub_Name "$vms_started"))}
              right: {(DQ (True))}
            )
        )
        (C {(VBoxManage)} {(snapshot)} {(bcpc-vm2)} {(take)} {(Post-Cobble)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (DBracket
          expr: 
            (BoolBinary
              op_id: BoolBinary_GlobDEqual
              left: {(DQ ($ VSub_Name "$vms_started"))}
              right: {(DQ (True))}
            )
        )
        (C {(VBoxManage)} {(snapshot)} {(bcpc-vm3)} {(take)} {(Post-Cobble)})
      ]
      op_id: Op_DAmp
    )
    (C {(printf)} {(DQ ("#### Chef all the nodes") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))})
    (C {(vagrant)} {(ssh)} {(-c)} {(DQ ("sudo apt-get install -y sshpass"))})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:cobbler_pass)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(vagrant)} {(ssh)} {(-c)} 
                        {
                          (DQ ("cd chef-bcpc; knife data bag show configs ") 
                            ($ VSub_Name "$ENVIRONMENT") (" | grep 'cobbler-root-password:'|sed 's/.* //'")
                          )
                        }
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [692 704]
              )
            }
          spids: [691]
        )
      ]
      spids: [691]
    )
    (C {(printf)} 
      {(DQ ("#### Chef the first headnode(s)") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))}
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (Pipeline
                  children: [
                    (C {(vagrant)} {(ssh)} {(-c)} 
                      {
                        (DQ ("cd chef-bcpc; ./cluster-assign-roles.sh ") ($ VSub_Name "$ENVIRONMENT") 
                          (" bcpc-vm1")
                        )
                      }
                    )
                  ]
                  negated: True
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(printf)} 
              {
                (DQ ("## set the first machine to admin") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
                )
              }
            )
            (C {(vagrant)} {(ssh)} {(-c)} 
              {
                (SQ 
                  <
"cd chef-bcpc; echo -e \"/\\\"admin\\\": false\\ns/false/true\\nw\\nq\\n\" | EDITOR=ed knife client edit `knife client list | grep bcpc-vm1`"
                  >
                )
              }
            )
            (C {(vagrant)} {(ssh)} {(-c)} 
              {
                (DQ ("cd chef-bcpc; echo ") ($ VSub_Name "$cobbler_pass") 
                  (" | sudo knife bootstrap -E ") ($ VSub_Name "$ENVIRONMENT") (" -r 'role[BCPC-Headnode]' 10.0.100.11 -x ubuntu --sudo")
                )
              }
            )
          ]
          spids: [-1 731]
        )
      ]
      spids: [-1 772]
    )
    (ForEach
      iter_name: i
      iter_words: [{(2)} {(3)}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (C {(printf)} 
              {
                (DQ ("## Machine bcpc-vm") (${ VSub_Name i) 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
                )
              }
            )
            (C {(vagrant)} {(ssh)} {(-c)} 
              {
                (DQ ("cd chef-bcpc; ./cluster-assign-roles.sh ") ($ VSub_Name "$ENVIRONMENT") 
                  (" bcpc-vm") ($ VSub_Name "$i")
                )
              }
            )
          ]
          spids: [786 813]
        )
      spids: [780 784]
    )
    (C {(printf)} {(DQ ("Snapshotting post-Cobbler") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))})
    (C {(VBoxManage)} {(snapshot)} {(bcpc-vm1)} {(take)} {(Full-Shoes)})
    (C {(VBoxManage)} {(snapshot)} {(bcpc-vm2)} {(take)} {(Full-Shoes)})
    (C {(VBoxManage)} {(snapshot)} {(bcpc-vm3)} {(take)} {(Full-Shoes)})
  ]
)