#!/bin/bash
# Script to assign roles to cluster nodes based on a definition in cluster.txt :
#
# - If no hostname is provided, all nodes will be attempted
#
# - if a nodename is provided, either by hostname or ip address, only
#   that node will be attempted
#
# - if the special nodename "heads" is given, all head nodes will be
#   attempted
#
# - if the special nodename "workers" is given, all work nodes will be
#   attempted
#
# - A node may be excluded by setting its role to something other than
#   "head" or "work" in cluster.txt. For example "done" might be
#   useful for nodes that have been completed
set -e
if [[ -z "$1" ]] {
    echo "Usage : $0 environment (hostname)"
    exit 1
}

global ENVIRONMENT := $1
global EXACTHOST := $2

if [[ ! -f "environments/$ENVIRONMENT.json" ]] {
    echo "Error: Couldn't find '$ENVIRONMENT.json'. Did you forget to pass the environment as first param?"
    exit 1
}TODO 

declare -A FQDNS = ''

while read HOST MACADDR IPADDR ILOIPADDR DOMAIN ROLE {
    if [[ -z "$EXACTHOST" || "$EXACTHOST" = all || "$EXACTHOST" = "$HOST" || "$EXACTHOST" = "$IPADDR" || "$EXACTHOST" = "heads" && "$ROLE" = "head" || "$EXACTHOST" = "workers" && "$ROLE" = "work" ]] {
        global IDX := $[echo $IPADDR | tr '.' '-]
        if [[ "$ROLE" = "bootstrap" ]] {
            continue
        }
        if   [[ "$ROLE" = head ]] {
            global HEADS := ""$HEADS $IPADDR""
            FQDNS["$IDX"]="$(HOST).$(DOMAIN)"
        } elif [[ "$ROLE" = work ]] {
            global WORKERS := ""$WORKERS $IPADDR""
            FQDNS["$IDX"]="$(HOST).$(DOMAIN)"
        }  
    }
} < cluster.txt
echo "heads : $HEADS"
echo "workers : $WORKERS"

global PASSWD := $[knife data bag show configs $ENVIRONMENT | grep "cobbler-root-password:" | awk ' {print $2}]
# All nodes now use an unbundled initialisation - chef is installed from
# a .deb (allowing disconnected working) and then the node is
# bootstrapped with no role to start, and then it is made admin, and
# then the role is assigned, finally chef-client is run
for HEAD in [$HEADS] {
    global MATCH := $HEAD
    echo "About to bootstrap head node $HEAD..."
    ./chefit.sh $HEAD $ENVIRONMENT
    echo $PASSWD | sudo knife bootstrap -E $ENVIRONMENT $HEAD -x ubuntu  -P $PASSWD --sudo
    global IDX := $[echo $HEAD | tr '.' '-]
    global FQDN := $(FQDNS["$IDX"])
    knife actor map
    knife group add actor admins $FQDN
    knife node run_list add $FQDN 'role[BCPC-Headnode]'
    global SSHCMD := ""./nodessh.sh $ENVIRONMENT $HEAD""
    $SSHCMD "/home/ubuntu/finish-head.sh" sudo  
}
# As of R5, we seem to need to use the two-step bootstrap for work nodes too
for WORKER in [$WORKERS] {
    global MATCH := $WORKER
    echo "About to bootstrap worker worker $WORKER..."
    ./chefit.sh $WORKER $ENVIRONMENT
    echo $PASSWD | sudo knife bootstrap -E $ENVIRONMENT $WORKER -x ubuntu -P $PASSWD --sudo
    global IDX := $[echo $WORKER | tr '.' '-]
    global FQDN := $(FQDNS["$IDX"])
    knife actor map
    knife group add actor admins $FQDN
    knife node run_list add $FQDN 'role[BCPC-Worknode]'
    global SSHCMD := ""./nodessh.sh $ENVIRONMENT $WORKER""
    $SSHCMD "/home/ubuntu/finish-worker.sh" sudo    
}
if [[ -z "$MATCH" ]] {
    echo "Warning: No nodes found"
}

(CommandList
  children: [
    (C {(set)} {(-e)})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (DBracket expr:(BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Number "$1"))}))
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(echo)} {(DQ ("Usage : ") ($ VSub_Number "$0") (" environment (hostname)"))})
            (C {(exit)} {(1)})
          ]
          spids: [-1 68]
        )
      ]
      spids: [-1 84]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:ENVIRONMENT)
          op: Equal
          rhs: {($ VSub_Number "$1")}
          spids: [87]
        )
      ]
      spids: [87]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:EXACTHOST)
          op: Equal
          rhs: {($ VSub_Number "$2")}
          spids: [90]
        )
      ]
      spids: [90]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (LogicalNot
                      child: 
                        (BoolUnary
                          op_id: BoolUnary_f
                          child: {(DQ (environments/) ($ VSub_Name "$ENVIRONMENT") (.json))}
                        )
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(echo)} 
              {
                (DQ ("Error: Couldn't find '") ($ VSub_Name "$ENVIRONMENT") 
                  (".json'. Did you forget to pass the environment as first param?")
                )
              }
            )
            (C {(exit)} {(1)})
          ]
          spids: [-1 111]
        )
      ]
      spids: [-1 127]
    )
    (Assignment
      keyword: Assign_Declare
      flags: ["'-A'"]
      pairs: [(assign_pair lhs:(LhsName name:FQDNS) op:Equal spids:[134])]
      spids: [130]
    )
    (While
      cond: [
        (Sentence
          child: (C {(read)} {(HOST)} {(MACADDR)} {(IPADDR)} {(ILOIPADDR)} {(DOMAIN)} {(ROLE)})
          terminator: <Op_Semi ";">
        )
      ]
      body: 
        (DoGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalOr
                              left: 
                                (BoolUnary
                                  op_id: BoolUnary_z
                                  child: {(DQ ($ VSub_Name "$EXACTHOST"))}
                                )
                              right: 
                                (LogicalOr
                                  left: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobEqual
                                      left: {(DQ ($ VSub_Name "$EXACTHOST"))}
                                      right: {(all)}
                                    )
                                  right: 
                                    (LogicalOr
                                      left: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobEqual
                                          left: {(DQ ($ VSub_Name "$EXACTHOST"))}
                                          right: {(DQ ($ VSub_Name "$HOST"))}
                                        )
                                      right: 
                                        (LogicalOr
                                          left: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobEqual
                                              left: {(DQ ($ VSub_Name "$EXACTHOST"))}
                                              right: {(DQ ($ VSub_Name "$IPADDR"))}
                                            )
                                          right: 
                                            (LogicalOr
                                              left: 
                                                (LogicalAnd
                                                  left: 
                                                    (BoolBinary
                                                      op_id: BoolBinary_GlobEqual
                                                      left: {(DQ ($ VSub_Name "$EXACTHOST"))}
                                                      right: {(DQ (heads))}
                                                    )
                                                  right: 
                                                    (BoolBinary
                                                      op_id: BoolBinary_GlobEqual
                                                      left: {(DQ ($ VSub_Name "$ROLE"))}
                                                      right: {(DQ (head))}
                                                    )
                                                )
                                              right: 
                                                (LogicalAnd
                                                  left: 
                                                    (BoolBinary
                                                      op_id: BoolBinary_GlobEqual
                                                      left: {(DQ ($ VSub_Name "$EXACTHOST"))}
                                                      right: {(DQ (workers))}
                                                    )
                                                  right: 
                                                    (BoolBinary
                                                      op_id: BoolBinary_GlobEqual
                                                      left: {(DQ ($ VSub_Name "$ROLE"))}
                                                      right: {(DQ (work))}
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:IDX)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(echo)} {($ VSub_Name "$IPADDR")})
                                          (C {(tr)} {(SQ <.>)} {(SQ <->)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [256 272]
                              )
                            }
                          spids: [255]
                        )
                      ]
                      spids: [255]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobEqual
                                      left: {(DQ ($ VSub_Name "$ROLE"))}
                                      right: {(DQ (bootstrap))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [-1 292]
                        )
                      ]
                      spids: [-1 298]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobEqual
                                      left: {(DQ ($ VSub_Name "$ROLE"))}
                                      right: {(head)}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:HEADS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$HEADS") (" ") ($ VSub_Name "$IPADDR"))}
                                  spids: [319]
                                )
                              ]
                              spids: [319]
                            )
                            (C 
                              {(FQDNS) (Lit_Other "[") (DQ ($ VSub_Name "$IDX")) (Lit_Other "]") 
                                (Lit_Other "=") (DQ (${ VSub_Name HOST) (.) (${ VSub_Name DOMAIN))
                              }
                            )
                          ]
                          spids: [-1 316]
                        )
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobEqual
                                      left: {(DQ ($ VSub_Name "$ROLE"))}
                                      right: {(work)}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:WORKERS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$WORKERS") (" ") ($ VSub_Name "$IPADDR"))}
                                  spids: [363]
                                )
                              ]
                              spids: [363]
                            )
                            (C 
                              {(FQDNS) (Lit_Other "[") (DQ ($ VSub_Name "$IDX")) (Lit_Other "]") 
                                (Lit_Other "=") (DQ (${ VSub_Name HOST) (.) (${ VSub_Name DOMAIN))
                              }
                            )
                          ]
                          spids: [345 360]
                        )
                      ]
                      spids: [-1 389]
                    )
                  ]
                  spids: [-1 252]
                )
              ]
              spids: [-1 393]
            )
          ]
          spids: [154 395]
        )
      redirects: [(Redir op_id:Redir_Less fd:-1 arg_word:{(cluster.txt)} spids:[397])]
    )
    (C {(echo)} {(DQ ("heads : ") ($ VSub_Name "$HEADS"))})
    (C {(echo)} {(DQ ("workers : ") ($ VSub_Name "$WORKERS"))})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PASSWD)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(knife)} {(data)} {(bag)} {(show)} {(configs)} {($ VSub_Name "$ENVIRONMENT")})
                          (C {(grep)} {(DQ ("cobbler-root-password:"))})
                          (C {(awk)} {(SQ <" {print $2}">)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_Backtick "`">
                spids: [417 445]
              )
            }
          spids: [416]
        )
      ]
      spids: [416]
    )
    (ForEach
      iter_name: HEAD
      iter_words: [{($ VSub_Name "$HEADS")}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:MATCH)
                  op: Equal
                  rhs: {($ VSub_Name "$HEAD")}
                  spids: [471]
                )
              ]
              spids: [471]
            )
            (C {(echo)} {(DQ ("About to bootstrap head node ") ($ VSub_Name "$HEAD") (...))})
            (C {(./chefit.sh)} {($ VSub_Name "$HEAD")} {($ VSub_Name "$ENVIRONMENT")})
            (Pipeline
              children: [
                (C {(echo)} {($ VSub_Name "$PASSWD")})
                (C {(sudo)} {(knife)} {(bootstrap)} {(-E)} {($ VSub_Name "$ENVIRONMENT")} 
                  {($ VSub_Name "$HEAD")} {(-x)} {(ubuntu)} {(-P)} {($ VSub_Name "$PASSWD")} {(--sudo)}
                )
              ]
              negated: False
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:IDX)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(echo)} {($ VSub_Name "$HEAD")})
                                  (C {(tr)} {(SQ <.>)} {(SQ <->)})
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_Backtick "`">
                        spids: [521 537]
                      )
                    }
                  spids: [520]
                )
              ]
              spids: [520]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:FQDN)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name FQDNS>
                        bracket_op: (ArrayIndex expr:(ArithWord w:{(DQ ($ VSub_Name "$IDX"))}))
                        spids: [541 548]
                      )
                    }
                  spids: [540]
                )
              ]
              spids: [540]
            )
            (C {(knife)} {(actor)} {(map)})
            (C {(knife)} {(group)} {(add)} {(actor)} {(admins)} {($ VSub_Name "$FQDN")})
            (C {(knife)} {(node)} {(run_list)} {(add)} {($ VSub_Name "$FQDN")} 
              {(SQ <"role[BCPC-Headnode]">)}
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SSHCMD)
                  op: Equal
                  rhs: 
                    {(DQ ("./nodessh.sh ") ($ VSub_Name "$ENVIRONMENT") (" ") ($ VSub_Name "$HEAD"))}
                  spids: [586]
                )
              ]
              spids: [586]
            )
            (C {($ VSub_Name "$SSHCMD")} {(DQ (/home/ubuntu/finish-head.sh))} {(sudo)})
          ]
          spids: [468 604]
        )
      spids: [464 466]
    )
    (ForEach
      iter_name: WORKER
      iter_words: [{($ VSub_Name "$WORKERS")}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:MATCH)
                  op: Equal
                  rhs: {($ VSub_Name "$WORKER")}
                  spids: [621]
                )
              ]
              spids: [621]
            )
            (C {(echo)} {(DQ ("About to bootstrap worker worker ") ($ VSub_Name "$WORKER") (...))})
            (C {(./chefit.sh)} {($ VSub_Name "$WORKER")} {($ VSub_Name "$ENVIRONMENT")})
            (Pipeline
              children: [
                (C {(echo)} {($ VSub_Name "$PASSWD")})
                (C {(sudo)} {(knife)} {(bootstrap)} {(-E)} {($ VSub_Name "$ENVIRONMENT")} 
                  {($ VSub_Name "$WORKER")} {(-x)} {(ubuntu)} {(-P)} {($ VSub_Name "$PASSWD")} {(--sudo)}
                )
              ]
              negated: False
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:IDX)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(echo)} {($ VSub_Name "$WORKER")})
                                  (C {(tr)} {(SQ <.>)} {(SQ <->)})
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_Backtick "`">
                        spids: [671 687]
                      )
                    }
                  spids: [670]
                )
              ]
              spids: [670]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:FQDN)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name FQDNS>
                        bracket_op: (ArrayIndex expr:(ArithWord w:{(DQ ($ VSub_Name "$IDX"))}))
                        spids: [691 698]
                      )
                    }
                  spids: [690]
                )
              ]
              spids: [690]
            )
            (C {(knife)} {(actor)} {(map)})
            (C {(knife)} {(group)} {(add)} {(actor)} {(admins)} {($ VSub_Name "$FQDN")})
            (C {(knife)} {(node)} {(run_list)} {(add)} {($ VSub_Name "$FQDN")} 
              {(SQ <"role[BCPC-Worknode]">)}
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SSHCMD)
                  op: Equal
                  rhs: 
                    {
                      (DQ ("./nodessh.sh ") ($ VSub_Name "$ENVIRONMENT") (" ") ($ VSub_Name "$WORKER"))
                    }
                  spids: [736]
                )
              ]
              spids: [736]
            )
            (C {($ VSub_Name "$SSHCMD")} {(DQ (/home/ubuntu/finish-worker.sh))} {(sudo)})
          ]
          spids: [618 754]
        )
      spids: [614 616]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (DBracket expr:(BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$MATCH"))}))
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(echo)} {(DQ ("Warning: No nodes found"))})]
          spids: [-1 769]
        )
      ]
      spids: [-1 778]
    )
  ]
)