(CommandList
  children: [
    (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' [role|IP] [verbose]"))})
            (C {(exit)})
          ]
          spids: [-1 79]
        )
      ]
      spids: [-1 93]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (BoolUnary
                      op_id: BoolUnary_z
                      child: 
                        {
                          (CommandSubPart
                            command_list: (CommandList children:[(C {(which)} {(fping)})])
                            left_token: <Left_Backtick "`">
                            spids: [101 105]
                          )
                        }
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(echo)} 
              {
                (DQ ("This tool uses fping. You should be able to install fping with ") 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [(C {(sudo)} {(apt-get)} {(install)} {(fping)})]
                      )
                    left_token: <Left_Backtick "`">
                    spids: [117 125]
                  )
                )
              }
            )
            (C {(exit)})
          ]
          spids: [-1 110]
        )
      ]
      spids: [-1 131]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:SOCKETDIR)
          op: Equal
          rhs: {(${ VSub_Name HOME) (/.ssh/sockets)}
          spids: [134]
        )
      ]
      spids: [134]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (LogicalNot
                      child: (BoolUnary op_id:BoolUnary_d child:{($ VSub_Name "$SOCKETDIR")})
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(mkdir)} {(${ VSub_Name SOCKETDIR)})
            (C {(chmod)} {(a) (Lit_Other "+") (rwx)} {(${ VSub_Name SOCKETDIR)})
          ]
          spids: [-1 153]
        )
      ]
      else_action: [(C {(ls)} {(${ VSub_Name SOCKETDIR)})]
      spids: [173 182]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:SSH_COMMAND_OPTS)
          op: Equal
          rhs: 
            {
              (DQ ("-o ControlMaster=auto -o ControlPath=") (${ VSub_Name SOCKETDIR) 
                ("/%r@%h-%p -o ControlPersist=600")
              )
            }
          spids: [185]
        )
      ]
      spids: [185]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:SSH_COMMON)
          op: Equal
          rhs: 
            {
              (DQ 
                (
"-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o VerifyHostKeyDNS=no"
                )
              )
            }
          spids: [194]
        )
      ]
      spids: [194]
    )
    (C {(echo)} {(DQ ($ VSub_Number "$0") (" : Checking which hosts are online..."))})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:UPHOSTS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(./cluster-whatsup-silent.sh)} {($ VSub_Number "$2")})]
                  )
                left_token: <Left_Backtick "`">
                spids: [208 212]
              )
            }
          spids: [207]
        )
      ]
      spids: [207]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:ENVIRONMENT)
          op: Equal
          rhs: {(DQ ($ VSub_Number "$1"))}
          spids: [215]
        )
      ]
      spids: [215]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:HOSTWANTED)
          op: Equal
          rhs: {(DQ ($ VSub_Number "$2"))}
          spids: [220]
        )
      ]
      spids: [220]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:VERBOSE)
          op: Equal
          rhs: {(DQ ($ VSub_Number "$3"))}
          spids: [225]
        )
      ]
      spids: [225]
    )
    (FuncDef
      name: vtrace
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Name "$VERBOSE"))})
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (ForEach
                      iter_name: STR
                      iter_words: [{(DQ ($ VSub_At "$@"))}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [(C {(echo)} {(-e)} {($ VSub_Name "$STR")})]
                          spids: [264 274]
                        )
                      spids: [258 262]
                    )
                  ]
                  spids: [-1 250]
                )
              ]
              spids: [-1 277]
            )
          ]
          spids: [234]
        )
      spids: [230 233]
    )
    (FuncDef
      name: vftrace
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalNot
                              child: (BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$VERBOSE"))})
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(printf)} {(DQ ($ VSub_At "$@"))})]
                  spids: [-1 310]
                )
              ]
              spids: [-1 320]
            )
          ]
          spids: [292]
        )
      spids: [288 291]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:KNIFESTAT)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (SimpleCommand
                            words: [
                              {(knife)}
                              {(data)}
                              {(bag)}
                              {(show)}
                              {(configs)}
                              {($ VSub_Name "$ENVIRONMENT")}
                            ]
                            redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[342])]
                          )
                          (C {(grep)} {(ERROR)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_Backtick "`">
                spids: [329 350]
              )
            }
          spids: [328]
        )
      ]
      spids: [328]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (LogicalNot
                      child: (BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$KNIFESTAT"))})
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(echo)} {(DQ ("knife error ") ($ VSub_Name "$KNIFESTAT") (" when showing the config"))})
            (C {(exit)})
          ]
          spids: [-1 367]
        )
      ]
      spids: [-1 381]
    )
    (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: [388 416]
              )
            }
          spids: [387]
        )
      ]
      spids: [387]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (DBracket expr:(BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$PASSWD"))}))
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(echo)} {(DQ ("Failed to retrieve 'cobbler-root-password'"))}) (C {(exit)})]
          spids: [-1 431]
        )
      ]
      spids: [-1 443]
    )
    (Assignment
      keyword: Assign_Declare
      flags: ["'-A'"]
      pairs: [(assign_pair lhs:(LhsName name:HOSTNAMES) op:Equal spids:[451])]
      spids: [447]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (DBracket expr:(BoolUnary op_id:BoolUnary_f child:{(cluster.txt)}))
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (While
              cond: [
                (Sentence
                  child: 
                    (C {(read)} {(HOSTNAME)} {(MACADDR)} {(IPADDR)} {(ILOIPADDR)} {(DOMAIN)} {(ROLE)})
                  terminator: <Op_Semi ";">
                )
              ]
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobEqual
                                      left: {($ VSub_Name "$HOSTNAME")}
                                      right: {(DQ (end))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [-1 503]
                        )
                      ]
                      spids: [-1 509]
                    )
                    (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 529]
                        )
                      ]
                      spids: [-1 535]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:THISUP)
                          op: Equal
                          rhs: {(DQ (false))}
                          spids: [538]
                        )
                      ]
                      spids: [538]
                    )
                    (ForEach
                      iter_name: UPHOST
                      iter_words: [{($ VSub_Name "$UPHOSTS")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobEqual
                                              left: {(DQ ($ VSub_Name "$IPADDR"))}
                                              right: {(DQ ($ VSub_Name "$UPHOST"))}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:THISUP)
                                          op: Equal
                                          rhs: {(DQ (true))}
                                          spids: [576]
                                        )
                                      ]
                                      spids: [576]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:UP)
                                          op: Equal
                                          rhs: 
                                            {
                                              (ArithSubPart
                                                anode: 
                                                  (ArithBinary
                                                    op_id: Arith_Plus
                                                    left: (ArithVarRef name:UP)
                                                    right: (ArithWord w:{(Lit_Digits 1)})
                                                  )
                                                spids: [583 589]
                                              )
                                            }
                                          spids: [582]
                                        )
                                      ]
                                      spids: [582]
                                    )
                                  ]
                                  spids: [-1 573]
                                )
                              ]
                              spids: [-1 592]
                            )
                          ]
                          spids: [553 595]
                        )
                      spids: [549 551]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (LogicalOr
                                      left: 
                                        (BoolUnary
                                          op_id: BoolUnary_z
                                          child: {(DQ ($ VSub_Name "$HOSTWANTED"))}
                                        )
                                      right: 
                                        (LogicalOr
                                          left: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobEqual
                                              left: {(DQ ($ VSub_Name "$HOSTWANTED"))}
                                              right: {(all)}
                                            )
                                          right: 
                                            (LogicalOr
                                              left: 
                                                (BoolBinary
                                                  op_id: BoolBinary_GlobEqual
                                                  left: {(DQ ($ VSub_Name "$HOSTWANTED"))}
                                                  right: {(DQ ($ VSub_Name "$ROLE"))}
                                                )
                                              right: 
                                                (LogicalOr
                                                  left: 
                                                    (BoolBinary
                                                      op_id: BoolBinary_GlobEqual
                                                      left: {(DQ ($ VSub_Name "$HOSTWANTED"))}
                                                      right: {(DQ ($ VSub_Name "$IPADDR"))}
                                                    )
                                                  right: 
                                                    (BoolBinary
                                                      op_id: BoolBinary_GlobEqual
                                                      left: {(DQ ($ VSub_Name "$HOSTWANTED"))}
                                                      right: {(DQ ($ VSub_Name "$HOSTNAME"))}
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobEqual
                                              left: {(DQ ($ VSub_Name "$THISUP"))}
                                              right: {(DQ (false))}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(echo)} {(DQ ($ VSub_Name "$HOSTNAME") (" is down"))})
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [-1 677]
                                )
                              ]
                              else_action: [(C {(vtrace)} {(DQ ($ VSub_Name "$HOSTNAME") (" is up"))})]
                              spids: [691 702]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (LogicalAnd
                                              left: 
                                                (LogicalNot
                                                  child: 
                                                    (BoolBinary
                                                      op_id: BoolBinary_GlobEqual
                                                      left: {(DQ ($ VSub_Name "$ROLE"))}
                                                      right: {(DQ (head))}
                                                    )
                                                )
                                              right: 
                                                (LogicalAnd
                                                  left: 
                                                    (LogicalNot
                                                      child: 
                                                        (BoolBinary
                                                          op_id: BoolBinary_GlobEqual
                                                          left: {(DQ ($ VSub_Name "$ROLE"))}
                                                          right: {(DQ (work))}
                                                        )
                                                    )
                                                  right: 
                                                    (LogicalNot
                                                      child: 
                                                        (BoolBinary
                                                          op_id: BoolBinary_GlobEqual
                                                          left: {(DQ ($ VSub_Name "$ROLE"))}
                                                          right: {(DQ (storage-work))}
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(vtrace)} 
                                      {
                                        (DQ ($ VSub_Name "$HOSTNAME") (" : unrecognized ") 
                                          ($ VSub_Name "$ROLE") (" - skipping ")
                                        )
                                      }
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:UP)
                                          op: Equal
                                          rhs: 
                                            {
                                              (ArithSubPart
                                                anode: 
                                                  (ArithBinary
                                                    op_id: Arith_Minus
                                                    left: (ArithVarRef name:UP)
                                                    right: (ArithWord w:{(Lit_Digits 1)})
                                                  )
                                                spids: [766 772]
                                              )
                                            }
                                          spids: [765]
                                        )
                                      ]
                                      spids: [765]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [-1 752]
                                )
                              ]
                              spids: [-1 778]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:HOSTS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$HOSTS") (" ") ($ VSub_Name "$IPADDR"))}
                                  spids: [781]
                                )
                              ]
                              spids: [781]
                            )
                            (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: [790 806]
                                      )
                                    }
                                  spids: [789]
                                )
                              ]
                              spids: [789]
                            )
                            (C 
                              {(HOSTNAMES) (Lit_Other "[") (DQ ($ VSub_Name "$IDX")) (Lit_Other "]") 
                                (Lit_Other "=") (DQ ($ VSub_Name "$HOSTNAME"))
                              }
                            )
                          ]
                          spids: [-1 657]
                        )
                      ]
                      spids: [-1 821]
                    )
                  ]
                  spids: [485 824]
                )
              redirects: [(Redir op_id:Redir_Less fd:-1 arg_word:{(cluster.txt)} spids:[826])]
            )
            (C {(vtrace)} {(DQ ("HOSTS = ") ($ VSub_Name "$HOSTS"))})
            (C {(echo)})
            (ForEach
              iter_name: HOST
              iter_words: [{($ VSub_Name "$HOSTS")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (SimpleCommand
                      words: [
                        {(sshpass)}
                        {(-p)}
                        {(DQ ($ VSub_Name "$PASSWD"))}
                        {(ssh)}
                        {($ VSub_Name "$SSH_COMMAND_OPTS")}
                        {($ VSub_Name "$SSH_COMMON")}
                        {(-Mn)}
                        {(ubuntu) (Lit_Other "@") ($ VSub_Name "$HOST")}
                      ]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(/dev/null)}
                          spids: [882]
                        )
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 2
                          arg_word: {(1)}
                          spids: [885]
                        )
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:SSH)
                          op: Equal
                          rhs: 
                            {
                              (DQ ("ssh ") ($ VSub_Name "$SSH_COMMAND_OPTS") (" ") 
                                ($ VSub_Name "$SSH_COMMON") (" ubuntu@") ($ VSub_Name "$HOST")
                              )
                            }
                          spids: [891]
                        )
                      ]
                      spids: [891]
                    )
                    (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 "$HOST")})
                                          (C {(tr)} {(SQ <.>)} {(SQ <->)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [905 921]
                              )
                            }
                          spids: [904]
                        )
                      ]
                      spids: [904]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:NAME)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Name HOSTNAMES>
                                bracket_op: (ArrayIndex expr:(ArithWord w:{(DQ ($ VSub_Name "$IDX"))}))
                                spids: [925 932]
                              )
                            }
                          spids: [924]
                        )
                      ]
                      spids: [924]
                    )
                    (C {(vtrace)} 
                      {
                        (DQ ("Checking ") ($ VSub_Name "$NAME") (" (") ($ VSub_Name "$HOST") (")..."))
                      }
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ROOTSIZE)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {($ VSub_Name "$SSH")} {(DQ ("df -k / | grep -v Filesystem"))})
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [949 955]
                              )
                            }
                          spids: [948]
                        )
                      ]
                      spids: [948]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ROOTSIZE)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(echo)} {($ VSub_Name "$ROOTSIZE")})
                                          (C {(awk)} {(SQ <"{print $4}">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [959 971]
                              )
                            }
                          spids: [958]
                        )
                      ]
                      spids: [958]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ROOTGIGS)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Slash
                                    left: (ArithVarRef name:ROOTSIZE)
                                    right: 
                                      (ArithBinary
                                        op_id: Arith_Star
                                        left: (ArithWord w:{(Lit_Digits 1024)})
                                        right: (ArithWord w:{(Lit_Digits 1024)})
                                      )
                                  )
                                spids: [975 984]
                              )
                            }
                          spids: [974]
                        )
                      ]
                      spids: [974]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_eq
                                      left: {($ VSub_Name "$ROOTSIZE")}
                                      right: {(0)}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ("Root fileystem size = ") ($ VSub_Name "$ROOTSIZE") (" (") 
                                  ($ VSub_Name "$ROOTGIGS") (" GB) !!WARNING!!")
                                )
                              }
                            )
                            (C {(echo)} 
                              {
                                (DQ 
                                  (
"Machine may still be installing the operating system ... skipping"
                                  )
                                )
                              }
                            )
                            (ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                          spids: [-1 1000]
                        )
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_lt
                                      left: {($ VSub_Name "$ROOTSIZE")}
                                      right: {(100) (Lit_Other "*") (1024) (Lit_Other "*") (1024)}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ("Root fileystem size = ") ($ VSub_Name "$ROOTSIZE") (" (") 
                                  ($ VSub_Name "$ROOTGIGS") (" GB) !!WARNING!!")
                                )
                              }
                            )
                          ]
                          spids: [1024 1041]
                        )
                      ]
                      else_action: [
                        (C {(vtrace)} 
                          {
                            (DQ ("Root fileystem size = ") ($ VSub_Name "$ROOTSIZE") (" (") 
                              ($ VSub_Name "$ROOTGIGS") (" GB) ")
                            )
                          }
                        )
                      ]
                      spids: [1055 1069]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolUnary
                                      op_id: BoolUnary_z
                                      child: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {($ VSub_Name "$SSH")} 
                                                    {
                                                      (DQ ("ip route show table main | grep default"))
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [1080 1086]
                                          )
                                        }
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ($ VSub_Name "$HOST") 
                                  (" no default route in table main !!WARNING!!")
                                )
                              }
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:BADHOSTS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$BADHOSTS") (" ") ($ VSub_Name "$HOST"))}
                                  spids: [1102]
                                )
                              ]
                              spids: [1102]
                            )
                          ]
                          spids: [-1 1091]
                        )
                      ]
                      else_action: [
                        (C {(vtrace)} {(DQ ($ VSub_Name "$HOST") (" has a default (main) route"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:MA)
                              op: Equal
                              rhs: 
                                {
                                  (ArithSubPart
                                    anode: 
                                      (ArithBinary
                                        op_id: Arith_Plus
                                        left: (ArithVarRef name:MA)
                                        right: (ArithWord w:{(Lit_Digits 1)})
                                      )
                                    spids: [1122 1128]
                                  )
                                }
                              spids: [1121]
                            )
                          ]
                          spids: [1121]
                        )
                      ]
                      spids: [1110 1131]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolUnary
                                      op_id: BoolUnary_z
                                      child: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {($ VSub_Name "$SSH")} 
                                                    {
                                                      (DQ ("ip route show table mgmt | grep default"))
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [1140 1146]
                                          )
                                        }
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {(DQ ($ VSub_Name "$HOST") (" no mgmt default route !!WARNING!!"))}
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:BADHOSTS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$BADHOSTS") (" ") ($ VSub_Name "$HOST"))}
                                  spids: [1162]
                                )
                              ]
                              spids: [1162]
                            )
                          ]
                          spids: [-1 1151]
                        )
                      ]
                      else_action: [
                        (C {(vtrace)} {(DQ ($ VSub_Name "$HOST") (" has a default mgmt route"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:MG)
                              op: Equal
                              rhs: 
                                {
                                  (ArithSubPart
                                    anode: 
                                      (ArithBinary
                                        op_id: Arith_Plus
                                        left: (ArithVarRef name:MG)
                                        right: (ArithWord w:{(Lit_Digits 1)})
                                      )
                                    spids: [1182 1188]
                                  )
                                }
                              spids: [1181]
                            )
                          ]
                          spids: [1181]
                        )
                      ]
                      spids: [1170 1191]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolUnary
                                      op_id: BoolUnary_z
                                      child: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {($ VSub_Name "$SSH")} 
                                                    {
                                                      (DQ 
                                                        (
"ip route show table storage | grep default"
                                                        )
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [1200 1206]
                                          )
                                        }
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ($ VSub_Name "$HOST") 
                                  (" has no storage default route !!WARNING!!")
                                )
                              }
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:BADHOSTS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$BADHOSTS") (" ") ($ VSub_Name "$HOST"))}
                                  spids: [1222]
                                )
                              ]
                              spids: [1222]
                            )
                          ]
                          spids: [-1 1211]
                        )
                      ]
                      else_action: [
                        (C {(vtrace)} {(DQ ($ VSub_Name "$HOST") (" has a default storage route"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:SG)
                              op: Equal
                              rhs: 
                                {
                                  (ArithSubPart
                                    anode: 
                                      (ArithBinary
                                        op_id: Arith_Plus
                                        left: (ArithVarRef name:SG)
                                        right: (ArithWord w:{(Lit_Digits 1)})
                                      )
                                    spids: [1242 1248]
                                  )
                                }
                              spids: [1241]
                            )
                          ]
                          spids: [1241]
                        )
                      ]
                      spids: [1230 1251]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:CHEF)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {($ VSub_Name "$SSH")} {(DQ ("which chef-client"))})]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [1255 1261]
                              )
                            }
                          spids: [1254]
                        )
                      ]
                      spids: [1254]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: (BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$CHEF"))})
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ($ VSub_Name "$HOST") 
                                  (
" doesn't seem to have chef installed so probably hasn't been assigned a role"
                                  )
                                )
                              }
                            )
                            (C {(echo)})
                            (ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                          spids: [-1 1277]
                        )
                      ]
                      spids: [-1 1294]
                    )
                    (C {($ VSub_Name "$SSH")} 
                      {
                        (DQ ("grep -m1 server /etc/ntp.conf | cut -f2 -d' ' > /tmp/clusterjunk.txt "))
                      }
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:DNS)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {($ VSub_Name "$SSH")} 
                                        {(DQ ("cat /tmp/clusterjunk.txt | xargs -n1 host"))}
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [1319 1325]
                              )
                            }
                          spids: [1318]
                        )
                      ]
                      spids: [1318]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_EqualTilde
                                      left: {(DQ ($ VSub_Name "$DNS"))}
                                      right: {(DQ ("not found"))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(echo)} {(DQ ($ VSub_Name "$DNS") (" !!WARNING!!"))})]
                          spids: [-1 1345]
                        )
                      ]
                      else_action: [
                        (C {(vtrace)} {(DQ ($ VSub_Name "$DNS"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:NTP)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {($ VSub_Name "$SSH")} 
                                            {
                                              (DQ 
                                                (
"cat /tmp/clusterjunk.txt | xargs -n1 ping -c 1 | grep ttl | cut -f4 -d' ' | cut -f1 -d:"
                                                )
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_Backtick "`">
                                    spids: [1381 1387]
                                  )
                                }
                              spids: [1380]
                            )
                          ]
                          spids: [1380]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolUnary
                                          op_id: BoolUnary_z
                                          child: {(DQ ($ VSub_Name "$NTP"))}
                                        )
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [(C {(echo)} {(DQ ("timeserver couldn't be pinged !!WARNING!!"))})]
                              spids: [-1 1403]
                            )
                          ]
                          else_action: [
                            (C {(vtrace)} {(DQ ("timeserver pinged ok : ") ($ VSub_Name "$NTP"))})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:TIME)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(./nodessh.sh)} {($ VSub_Name "$ENVIRONMENT")} 
                                                {($ VSub_Name "$HOST")} {(DQ ("cat /tmp/clusterjunk.txt | xargs -n1 ntpdate -q -p1"))}
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [1435 1445]
                                      )
                                    }
                                  spids: [1434]
                                )
                              ]
                              spids: [1434]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (LogicalNot
                                              child: 
                                                (BoolBinary
                                                  op_id: BoolBinary_EqualTilde
                                                  left: {(DQ ($ VSub_Name "$TIME"))}
                                                  right: {(DQ ("time server"))}
                                                )
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(echo)} {(DQ ("timeserver couldn't be used !!WARNING!!"))})
                                  ]
                                  spids: [-1 1466]
                                )
                              ]
                              else_action: [
                                (C {(vtrace)} {(DQ ("timeserver queried ok : ") ($ VSub_Name "$TIME"))})
                              ]
                              spids: [1476 1487]
                            )
                          ]
                          spids: [1413 1490]
                        )
                      ]
                      spids: [1360 1493]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:STAT)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {($ VSub_Name "$SSH")} {(DQ ("ceph -s | grep HEALTH"))})
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [1499 1505]
                              )
                            }
                          spids: [1498]
                        )
                      ]
                      spids: [1498]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:STAT)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(echo)} {($ VSub_Name "$STAT")})
                                          (C {(cut)} {(-f2)} {(-d) (Lit_Other ":")})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [1509 1522]
                              )
                            }
                          spids: [1508]
                        )
                      ]
                      spids: [1508]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_EqualTilde
                                      left: {(DQ ($ VSub_Name "$STAT"))}
                                      right: {(DQ (HEALTH_OK))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:STAT)
                                  op: Equal
                                  rhs: {(DQ (healthy))}
                                  spids: [1553]
                                )
                              ]
                              spids: [1553]
                            )
                          ]
                          spids: [-1 1542]
                        )
                      ]
                      spids: [-1 1559]
                    )
                    (C {(vftrace)} 
                      {
                        (DQ ($ VSub_Name "$HOST") (" %20s %s") 
                          (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
                        )
                      } {(ceph)} {(DQ ($ VSub_Name "$STAT"))}
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:SERVICE)
                          op: Equal
                          rhs: {(DQ (fluentd))}
                          spids: [1617]
                        )
                      ]
                      spids: [1617]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:FLUENTD)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {($ VSub_Name "$SSH")} 
                                        {
                                          (DQ 
                                            (
"ps w -C ruby -C td-agent --no-heading | grep -v chef-client"
                                            )
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [1624 1630]
                              )
                            }
                          spids: [1623]
                        )
                      ]
                      spids: [1623]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:STAT)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {($ VSub_Name "$SSH")} 
                                        {
                                          (DQ 
                                            (
"ps w -C ruby -C td-agent --no-heading | grep -v chef-client | wc -l"
                                            )
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [1634 1640]
                              )
                            }
                          spids: [1633]
                        )
                      ]
                      spids: [1633]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:STAT)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(echo)} {($ VSub_Name "$STAT")})
                                          (C {(cut)} {(-f2)} {(-d) (Lit_Other ":")})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [1644 1657]
                              )
                            }
                          spids: [1643]
                        )
                      ]
                      spids: [1643]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_EqualTilde
                                      left: {(DQ ($ VSub_Name "$STAT"))}
                                      right: {(2)}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:STAT)
                                  op: Equal
                                  rhs: {(DQ (" normal"))}
                                  spids: [1679]
                                )
                              ]
                              spids: [1679]
                            )
                          ]
                          spids: [-1 1676]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:STAT)
                              op: Equal
                              rhs: {(DQ ($ VSub_Name "$FLUENTD"))}
                              spids: [1688]
                            )
                          ]
                          spids: [1688]
                        )
                      ]
                      spids: [1685 1694]
                    )
                    (C {(vftrace)} 
                      {
                        (DQ ($ VSub_Name "$HOST") (" %20s %s") 
                          (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
                        )
                      } {(DQ ($ VSub_Name "$SERVICE"))} {(DQ ($ VSub_Name "$STAT"))}
                    )
                    (ForEach
                      iter_name: SERVICE
                      iter_words: [
                        {(glance-api)}
                        {(glance-registry)}
                        {(cinder-scheduler)}
                        {(cinder-volume)}
                        {(cinder-api)}
                        {(nova-api)}
                        {(nova-novncproxy)}
                        {(nova-scheduler)}
                        {(nova-consoleauth)}
                        {(nova-cert)}
                        {(nova-conductor)}
                        {(nova-compute)}
                        {(nova-network)}
                        {(haproxy)}
                        {(apache2)}
                        {(tpm)}
                      ]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:STAT)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {($ VSub_Name "$SSH")} 
                                                {
                                                  (DQ ("service ") ($ VSub_Name "$SERVICE") 
                                                    (" status 2>&1")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [1763 1771]
                                      )
                                    }
                                  spids: [1762]
                                )
                              ]
                              spids: [1762]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (LogicalNot
                                              child: 
                                                (BoolBinary
                                                  op_id: BoolBinary_EqualTilde
                                                  left: {(DQ ($ VSub_Name "$STAT"))}
                                                  right: {(DQ (unrecognized))}
                                                )
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (DBracket
                                                  expr: 
                                                    (BoolBinary
                                                      op_id: BoolBinary_GlobEqual
                                                      left: {(DQ ($ VSub_Name "$SERVICE"))}
                                                      right: {(DQ (apache2))}
                                                    )
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {(wget)}
                                                {(http) (Lit_Other ":") (//) ($ VSub_Name "$HOST")}
                                                {(-O-)}
                                                {(-t1)}
                                                {(-T1)}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: {(/dev/null)}
                                                  spids: [1857]
                                                )
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 2
                                                  arg_word: {(1)}
                                                  spids: [1860]
                                                )
                                              ]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (DBracket
                                                          expr: 
                                                            (BoolBinary
                                                              op_id: BoolBinary_GlobNEqual
                                                              left: {(DQ ($ VSub_QMark "$?"))}
                                                              right: {(0)}
                                                            )
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:STAT)
                                                          op: Equal
                                                          rhs: {(DQ (" !! not responding !!"))}
                                                          spids: [1882]
                                                        )
                                                      ]
                                                      spids: [1882]
                                                    )
                                                  ]
                                                  spids: [-1 1879]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:STAT)
                                                      op: Equal
                                                      rhs: {(DQ (" responding"))}
                                                      spids: [1891]
                                                    )
                                                  ]
                                                  spids: [1891]
                                                )
                                              ]
                                              spids: [1888 1897]
                                            )
                                          ]
                                          spids: [-1 1829]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:STAT)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {(echo)} {($ VSub_Name "$STAT")})
                                                              (C {(cut)} {(-f2)} {(-d) (DQ (":"))})
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [1908 1923]
                                                  )
                                                }
                                              spids: [1907]
                                            )
                                          ]
                                          spids: [1907]
                                        )
                                      ]
                                      spids: [1900 1926]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (DBracket
                                                  expr: 
                                                    (LogicalAnd
                                                      left: 
                                                        (LogicalNot
                                                          child: 
                                                            (BoolBinary
                                                              op_id: BoolBinary_EqualTilde
                                                              left: {(DQ ($ VSub_Name "$STAT"))}
                                                              right: {(DQ (start/running))}
                                                            )
                                                        )
                                                      right: 
                                                        (LogicalAnd
                                                          left: 
                                                            (LogicalNot
                                                              child: 
                                                                (BoolBinary
                                                                  op_id: BoolBinary_EqualTilde
                                                                  left: {(DQ ($ VSub_Name "$STAT"))}
                                                                  right: {(DQ ("haproxy is running"))}
                                                                )
                                                            )
                                                          right: 
                                                            (LogicalNot
                                                              child: 
                                                                (BoolBinary
                                                                  op_id: BoolBinary_EqualTilde
                                                                  left: {(DQ ($ VSub_Name "$STAT"))}
                                                                  right: {(DQ (responding))}
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(printf)} 
                                              {
                                                (DQ ($ VSub_Name "$HOST") (" %20s %s") 
                                                  (EscapedLiteralPart
                                                    token: <Lit_EscapedChar "\\n">
                                                  )
                                                )
                                              } {(DQ ($ VSub_Name "$SERVICE"))} {(DQ ($ VSub_Name "$STAT"))}
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:BADHOSTS)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$BADHOSTS") (" ") 
                                                        ($ VSub_Name "$HOST")
                                                      )
                                                    }
                                                  spids: [2002]
                                                )
                                              ]
                                              spids: [2002]
                                            )
                                          ]
                                          spids: [-1 1978]
                                        )
                                      ]
                                      else_action: [
                                        (C {(vftrace)} 
                                          {
                                            (DQ ($ VSub_Name "$HOST") (" %20s %s") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\n">
                                              )
                                            )
                                          } {(DQ ($ VSub_Name "$SERVICE"))} {(DQ ($ VSub_Name "$STAT"))}
                                        )
                                      ]
                                      spids: [2010 2030]
                                    )
                                  ]
                                  spids: [-1 1793]
                                )
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobEqual
                                              left: {(DQ ($ VSub_Name "$SERVICE"))}
                                              right: {(DQ (tpm))}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:STAT)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {($ VSub_Name "$SSH")} 
                                                        {
                                                          (DQ 
                                                            (
"cat /proc/sys/kernel/random/entropy_avail"
                                                            )
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [2054 2060]
                                              )
                                            }
                                          spids: [2053]
                                        )
                                      ]
                                      spids: [2053]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (DParen
                                                  child: 
                                                    (ArithBinary
                                                      op_id: Arith_Less
                                                      left: (ArithWord w:{(${ VSub_Name STAT)})
                                                      right: (ArithWord w:{(Lit_Digits 1000)})
                                                    )
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(printf)} 
                                              {
                                                (DQ ($ VSub_Name "$HOST") (" %20s %s") 
                                                  (EscapedLiteralPart
                                                    token: <Lit_EscapedChar "\\n">
                                                  )
                                                )
                                              } {(DQ ($ VSub_Name "$SERVICE"))} {(DQ ("Entropy low (") ($ VSub_Name "$STAT") (")"))}
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:BADHOSTS)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$BADHOSTS") (" ") 
                                                        ($ VSub_Name "$HOST")
                                                      )
                                                    }
                                                  spids: [2099]
                                                )
                                              ]
                                              spids: [2099]
                                            )
                                          ]
                                          spids: [-1 2077]
                                        )
                                      ]
                                      else_action: [
                                        (C {(vftrace)} 
                                          {
                                            (DQ ($ VSub_Name "$HOST") ("%20s %s") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\n">
                                              )
                                            )
                                          } {(DQ ($ VSub_Name "$SERVICE"))} {(DQ ("Entropy ok (") ($ VSub_Name "$STAT") (")"))}
                                        )
                                      ]
                                      spids: [2107 2129]
                                    )
                                  ]
                                  spids: [2033 2050]
                                )
                              ]
                              spids: [-1 2132]
                            )
                          ]
                          spids: [1759 2135]
                        )
                      spids: [1725 1757]
                    )
                    (C {(echo)})
                    (SimpleCommand
                      words: [
                        {(ssh)}
                        {($ VSub_Name "$SSH_COMMAND_OPTS")}
                        {(-O)}
                        {(exit)}
                        {(ubuntu) (Lit_Other "@") ($ VSub_Name "$HOST")}
                      ]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(/dev/null)}
                          spids: [2155]
                        )
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 2
                          arg_word: {(1)}
                          spids: [2158]
                        )
                      ]
                    )
                  ]
                  spids: [854 2163]
                )
              spids: [850 852]
            )
          ]
          spids: [-1 465]
        )
      ]
      else_action: [(C {(echo)} {(DQ ("Warning 'cluster.txt' not found"))})]
      spids: [2165 2174]
    )
    (C {(echo)} 
      {
        (DQ ($ VSub_Name "$ENVIRONMENT") (" cluster summary: ") ($ VSub_Name "$UP") (" hosts up. ") 
          ($ VSub_Name "$MA") (" hosts with default main route. ") ($ VSub_Name "$MG") (" hosts with default mgmt route. ") 
          ($ VSub_Name "$SG") (" hosts with default storage route")
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:BADHOSTS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [(C {(echo)} {($ VSub_Name "$BADHOSTS")}) (C {(uniq)}) (C {(sort)})]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_Backtick "`">
                spids: [2192 2204]
              )
            }
          spids: [2191]
        )
      ]
      spids: [2191]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (LogicalNot
                      child: (BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$BADHOSTS"))})
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(echo)} {(DQ ("Bad hosts ") ($ VSub_Name "$BADHOSTS") (" - definite issues on these"))})
          ]
          spids: [-1 2221]
        )
      ]
      spids: [-1 2232]
    )
  ]
)