(command.CommandList
  children: [
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: (bool_expr.Unary op_id:Id.BoolUnary_z child:{(DQ ($ Id.VSub_Number '$1'))})
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<echo>} 
              {(DQ <'Usage '> ($ Id.VSub_Number '$0') <' \'environment\' [role|IP] [verbose]'>)}
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [66 79]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Unary
                          op_id: Id.BoolUnary_z
                          child: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: (C {<which>} {<fping>})
                              )
                            }
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<echo>} 
              {
                (DQ <'This tool uses fping. You should be able to install fping with '> 
                  (command_sub
                    left_token: <Id.Left_Backtick '`'>
                    child: (C {<sudo>} {<apt-get>} {<install>} {<fping>})
                  )
                )
              }
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [95 112]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SOCKETDIR)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name HOME) <'/.ssh/sockets'>}
          spids: [138]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.LogicalNot
                          child: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_d
                              child: {($ Id.VSub_DollarName '$SOCKETDIR')}
                            )
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<mkdir>} {(${ Id.VSub_Name SOCKETDIR)})
            (C {<chmod>} {<a> <Id.Lit_Other '+'> <rwx>} {(${ Id.VSub_Name SOCKETDIR)})
          ]
          spids: [144 157]
        )
      ]
      else_action: [(C {<ls>} {(${ Id.VSub_Name SOCKETDIR)})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SSH_COMMAND_OPTS)
          op: assign_op.Equal
          rhs: 
            {
              (DQ <'-o ControlMaster=auto -o ControlPath='> (${ Id.VSub_Name SOCKETDIR) 
                <'/%r@%h-%p -o ControlPersist=600'>
              )
            }
          spids: [189]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SSH_COMMON)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                <
'-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o VerifyHostKeyDNS=no'
                >
              )
            }
          spids: [198]
        )
      ]
    )
    (C {<echo>} {(DQ ($ Id.VSub_Number '$0') <' : Checking which hosts are online...'>)})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:UPHOSTS)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                child: (C {<'./cluster-whatsup-silent.sh'>} {($ Id.VSub_Number '$2')})
              )
            }
          spids: [211]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ENVIRONMENT)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_Number '$1'))}
          spids: [221]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:HOSTWANTED)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_Number '$2'))}
          spids: [226]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:VERBOSE)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_Number '$3'))}
          spids: [231]
        )
      ]
    )
    (command.ShFunction
      name: vtrace
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: {(DQ ($ Id.VSub_DollarName '$VERBOSE'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ForEach
                      iter_name: STR
                      iter_words: [{(DQ ($ Id.VSub_At '$@'))}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [(C {<echo>} {<-e>} {($ Id.VSub_DollarName '$STR')})]
                        )
                    )
                  ]
                  spids: [243 256]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: vftrace
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalNot
                                  child: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_z
                                      child: {(DQ ($ Id.VSub_DollarName '$VERBOSE'))}
                                    )
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<printf>} {(DQ ($ Id.VSub_At '$@'))})]
                  spids: [301 316]
                )
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:KNIFESTAT)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                child: 
                  (command.Pipeline
                    children: [
                      (command.Simple
                        words: [
                          {<knife>}
                          {<Id.KW_Data data>}
                          {<bag>}
                          {<show>}
                          {<configs>}
                          {($ Id.VSub_DollarName '$ENVIRONMENT')}
                        ]
                        redirects: [
                          (redir
                            op: <Id.Redir_GreatAnd '2>&'>
                            loc: (redir_loc.Fd fd:2)
                            arg: {<1>}
                          )
                        ]
                        do_fork: T
                      )
                      (C {<grep>} {<ERROR>})
                    ]
                    negated: F
                  )
              )
            }
          spids: [334]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.LogicalNot
                          child: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {(DQ ($ Id.VSub_DollarName '$KNIFESTAT'))}
                            )
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<echo>} 
              {(DQ <'knife error '> ($ Id.VSub_DollarName '$KNIFESTAT') <' when showing the config'>)}
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [360 375]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PASSWD)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                child: 
                  (command.Pipeline
                    children: [
                      (C {<knife>} {<Id.KW_Data data>} {<bag>} {<show>} {<configs>} 
                        {($ Id.VSub_DollarName '$ENVIRONMENT')}
                      )
                      (C {<grep>} {(DQ <'cobbler-root-password:'>)})
                      (C {<awk>} {(SQ <' {print $2}'>)})
                    ]
                    negated: F
                  )
              )
            }
          spids: [395]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Unary
                          op_id: Id.BoolUnary_z
                          child: {(DQ ($ Id.VSub_DollarName '$PASSWD'))}
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ <'Failed to retrieve \'cobbler-root-password\''>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [428 441]
        )
      ]
    )
    (C {<declare>} {<-A>} {<HOSTNAMES>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: (bool_expr.Unary op_id:Id.BoolUnary_f child:{<cluster.txt>})
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (C {<read>} {<HOSTNAME>} {<MACADDR>} {<IPADDR>} {<ILOIPADDR>} {<DOMAIN>} {<ROLE>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobEqual
                                          left: {($ Id.VSub_DollarName '$HOSTNAME')}
                                          right: {(DQ <end>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(command.ControlFlow token:<Id.ControlFlow_Continue continue>)]
                          spids: [498 513]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$ROLE'))}
                                          right: {(DQ <bootstrap>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(command.ControlFlow token:<Id.ControlFlow_Continue continue>)]
                          spids: [522 539]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:THISUP)
                          op: assign_op.Equal
                          rhs: {(DQ <false>)}
                          spids: [548]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: UPHOST
                      iter_words: [{($ Id.VSub_DollarName '$UPHOSTS')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobEqual
                                                  left: {(DQ ($ Id.VSub_DollarName '$IPADDR'))}
                                                  right: {(DQ ($ Id.VSub_DollarName '$UPHOST'))}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:THISUP)
                                          op: assign_op.Equal
                                          rhs: {(DQ <true>)}
                                          spids: [586]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:UP)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (word_part.ExprSub
                                                left: <Id.Left_DollarBracket '$['>
                                                child: 
                                                  (expr.Binary
                                                    op: <Id.Arith_Plus _>
                                                    left: (Var UP)
                                                    right: (Const Id.Expr_DecInt 1)
                                                  )
                                              )
                                            }
                                          spids: [592]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [566 583]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.LogicalOr
                                          left: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_z
                                              child: {(DQ ($ Id.VSub_DollarName '$HOSTWANTED'))}
                                            )
                                          right: 
                                            (bool_expr.LogicalOr
                                              left: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobEqual
                                                  left: {(DQ ($ Id.VSub_DollarName '$HOSTWANTED'))}
                                                  right: {<all>}
                                                )
                                              right: 
                                                (bool_expr.LogicalOr
                                                  left: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobEqual
                                                      left: {(DQ ($ Id.VSub_DollarName '$HOSTWANTED'))}
                                                      right: {(DQ ($ Id.VSub_DollarName '$ROLE'))}
                                                    )
                                                  right: 
                                                    (bool_expr.LogicalOr
                                                      left: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobEqual
                                                          left: 
                                                            {
                                                              (DQ 
                                                                ($ Id.VSub_DollarName '$HOSTWANTED')
                                                              )
                                                            }
                                                          right: 
                                                            {(DQ ($ Id.VSub_DollarName '$IPADDR'))}
                                                        )
                                                      right: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobEqual
                                                          left: 
                                                            {
                                                              (DQ 
                                                                ($ Id.VSub_DollarName '$HOSTWANTED')
                                                              )
                                                            }
                                                          right: 
                                                            {(DQ ($ Id.VSub_DollarName '$HOSTNAME'))}
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobEqual
                                                  left: {(DQ ($ Id.VSub_DollarName '$THISUP'))}
                                                  right: {(DQ <false>)}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<echo>} {(DQ ($ Id.VSub_DollarName '$HOSTNAME') <' is down'>)})
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [670 687]
                                )
                              ]
                              else_action: [
                                (C {<vtrace>} {(DQ ($ Id.VSub_DollarName '$HOSTNAME') <' is up'>)})
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.LogicalAnd
                                                  left: 
                                                    (bool_expr.LogicalNot
                                                      child: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobEqual
                                                          left: {(DQ ($ Id.VSub_DollarName '$ROLE'))}
                                                          right: {(DQ <head>)}
                                                        )
                                                    )
                                                  right: 
                                                    (bool_expr.LogicalAnd
                                                      left: 
                                                        (bool_expr.LogicalNot
                                                          child: 
                                                            (bool_expr.Binary
                                                              op_id: Id.BoolBinary_GlobEqual
                                                              left: 
                                                                {(DQ ($ Id.VSub_DollarName '$ROLE'))}
                                                              right: {(DQ <work>)}
                                                            )
                                                        )
                                                      right: 
                                                        (bool_expr.LogicalNot
                                                          child: 
                                                            (bool_expr.Binary
                                                              op_id: Id.BoolBinary_GlobEqual
                                                              left: 
                                                                {(DQ ($ Id.VSub_DollarName '$ROLE'))}
                                                              right: {(DQ <storage-work>)}
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<vtrace>} 
                                      {
                                        (DQ ($ Id.VSub_DollarName '$HOSTNAME') <' : unrecognized '> 
                                          ($ Id.VSub_DollarName '$ROLE') <' - skipping '>
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:UP)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (word_part.ExprSub
                                                left: <Id.Left_DollarBracket '$['>
                                                child: 
                                                  (expr.Binary
                                                    op: <Id.Arith_Minus _>
                                                    left: (Var UP)
                                                    right: (Const Id.Expr_DecInt 1)
                                                  )
                                              )
                                            }
                                          spids: [775]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [715 762]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:HOSTS)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$HOSTS') <' '> 
                                        ($ Id.VSub_DollarName '$IPADDR')
                                      )
                                    }
                                  spids: [791]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IDX)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {($ Id.VSub_DollarName '$IPADDR')})
                                              (C {<tr>} {(SQ <.>)} {(SQ <->)})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  spids: [799]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      name: HOSTNAMES
                                      index: {(DQ ($ Id.VSub_DollarName '$IDX'))}
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$HOSTNAME'))}
                                  spids: [821]
                                )
                              ]
                            )
                          ]
                          spids: [608 667]
                        )
                      ]
                    )
                  ]
                )
              redirects: [(redir op:<Id.Redir_Less '<'> loc:(redir_loc.Fd fd:0) arg:{<cluster.txt>})]
            )
            (C {<vtrace>} {(DQ <'HOSTS = '> ($ Id.VSub_DollarName '$HOSTS'))})
            (C {<echo>})
            (command.ForEach
              iter_name: HOST
              iter_words: [{($ Id.VSub_DollarName '$HOSTS')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Simple
                      words: [
                        {<sshpass>}
                        {<-p>}
                        {(DQ ($ Id.VSub_DollarName '$PASSWD'))}
                        {<ssh>}
                        {($ Id.VSub_DollarName '$SSH_COMMAND_OPTS')}
                        {($ Id.VSub_DollarName '$SSH_COMMON')}
                        {<-Mn>}
                        {<ubuntu> <Id.Lit_At '@'> ($ Id.VSub_DollarName '$HOST')}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<'/dev/null'>}
                        )
                        (redir
                          op: <Id.Redir_GreatAnd '2>&'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<1>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:SSH)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'ssh '> ($ Id.VSub_DollarName '$SSH_COMMAND_OPTS') <' '> 
                                ($ Id.VSub_DollarName '$SSH_COMMON') <' ubuntu@'> ($ Id.VSub_DollarName '$HOST')
                              )
                            }
                          spids: [905]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IDX)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (C {<echo>} {($ Id.VSub_DollarName '$HOST')})
                                      (C {<tr>} {(SQ <.>)} {(SQ <->)})
                                    ]
                                    negated: F
                                  )
                              )
                            }
                          spids: [918]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:NAME)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name HOSTNAMES>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: {(DQ ($ Id.VSub_DollarName '$IDX'))}
                                  )
                              )
                            }
                          spids: [940]
                        )
                      ]
                    )
                    (C {<vtrace>} 
                      {
                        (DQ <'Checking '> ($ Id.VSub_DollarName '$NAME') <' ('> 
                          ($ Id.VSub_DollarName '$HOST') <')...'>
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ROOTSIZE)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (C {($ Id.VSub_DollarName '$SSH')} 
                                    {(DQ <'df -k / | grep -v Filesystem'>)}
                                  )
                              )
                            }
                          spids: [964]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ROOTSIZE)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (C {<echo>} {($ Id.VSub_DollarName '$ROOTSIZE')})
                                      (C {<awk>} {(SQ <'{print $4}'>)})
                                    ]
                                    negated: F
                                  )
                              )
                            }
                          spids: [976]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ROOTGIGS)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Slash
                                    left: <Id.Lit_ArithVarLike ROOTSIZE>
                                    right: 
                                      (arith_expr.Binary
                                        op_id: Id.Arith_Star
                                        left: {<Id.Lit_Digits 1024>}
                                        right: {<Id.Lit_Digits 1024>}
                                      )
                                  )
                              )
                            }
                          spids: [994]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$ROOTSIZE')}
                                          right: {<0>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ <'Root fileystem size = '> ($ Id.VSub_DollarName '$ROOTSIZE') 
                                  <' ('> ($ Id.VSub_DollarName '$ROOTGIGS') <' GB) !!WARNING!!'>
                                )
                              }
                            )
                            (C {<echo>} 
                              {
                                (DQ 
                                  <
'Machine may still be installing the operating system ... skipping'
                                  >
                                )
                              }
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Continue continue>
                            )
                          ]
                          spids: [1007 1020]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_lt
                                          left: {($ Id.VSub_DollarName '$ROOTSIZE')}
                                          right: 
                                            {<100> <Id.Lit_Other '*'> <1024> <Id.Lit_Other '*'> <1024>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ <'Root fileystem size = '> ($ Id.VSub_DollarName '$ROOTSIZE') 
                                  <' ('> ($ Id.VSub_DollarName '$ROOTGIGS') <' GB) !!WARNING!!'>
                                )
                              }
                            )
                          ]
                          spids: [1044 1061]
                        )
                      ]
                      else_action: [
                        (C {<vtrace>} 
                          {
                            (DQ <'Root fileystem size = '> ($ Id.VSub_DollarName '$ROOTSIZE') <' ('> 
                              ($ Id.VSub_DollarName '$ROOTGIGS') <' GB) '>
                            )
                          }
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_Backtick '`'>
                                                child: 
                                                  (C {($ Id.VSub_DollarName '$SSH')} 
                                                    {(DQ <'ip route show table main | grep default'>)}
                                                  )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ ($ Id.VSub_DollarName '$HOST') 
                                  <' no default route in table main !!WARNING!!'>
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BADHOSTS)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$BADHOSTS') <' '> 
                                        ($ Id.VSub_DollarName '$HOST')
                                      )
                                    }
                                  spids: [1124]
                                )
                              ]
                            )
                          ]
                          spids: [1094 1113]
                        )
                      ]
                      else_action: [
                        (C {<vtrace>} 
                          {(DQ ($ Id.VSub_DollarName '$HOST') <' has a default (main) route'>)}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:MA)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (word_part.ExprSub
                                    left: <Id.Left_DollarBracket '$['>
                                    child: 
                                      (expr.Binary
                                        op: <Id.Arith_Plus _>
                                        left: (Var MA)
                                        right: (Const Id.Expr_DecInt 1)
                                      )
                                  )
                                }
                              spids: [1143]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_Backtick '`'>
                                                child: 
                                                  (C {($ Id.VSub_DollarName '$SSH')} 
                                                    {(DQ <'ip route show table mgmt | grep default'>)}
                                                  )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ ($ Id.VSub_DollarName '$HOST') 
                                  <' no mgmt default route !!WARNING!!'>
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BADHOSTS)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$BADHOSTS') <' '> 
                                        ($ Id.VSub_DollarName '$HOST')
                                      )
                                    }
                                  spids: [1186]
                                )
                              ]
                            )
                          ]
                          spids: [1156 1175]
                        )
                      ]
                      else_action: [
                        (C {<vtrace>} 
                          {(DQ ($ Id.VSub_DollarName '$HOST') <' has a default mgmt route'>)}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:MG)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (word_part.ExprSub
                                    left: <Id.Left_DollarBracket '$['>
                                    child: 
                                      (expr.Binary
                                        op: <Id.Arith_Plus _>
                                        left: (Var MG)
                                        right: (Const Id.Expr_DecInt 1)
                                      )
                                  )
                                }
                              spids: [1205]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_Backtick '`'>
                                                child: 
                                                  (C {($ Id.VSub_DollarName '$SSH')} 
                                                    {
                                                      (DQ 
                                                        <
'ip route show table storage | grep default'
                                                        >
                                                      )
                                                    }
                                                  )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ ($ Id.VSub_DollarName '$HOST') 
                                  <' has no storage default route !!WARNING!!'>
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BADHOSTS)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$BADHOSTS') <' '> 
                                        ($ Id.VSub_DollarName '$HOST')
                                      )
                                    }
                                  spids: [1248]
                                )
                              ]
                            )
                          ]
                          spids: [1218 1237]
                        )
                      ]
                      else_action: [
                        (C {<vtrace>} 
                          {(DQ ($ Id.VSub_DollarName '$HOST') <' has a default storage route'>)}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:SG)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (word_part.ExprSub
                                    left: <Id.Left_DollarBracket '$['>
                                    child: 
                                      (expr.Binary
                                        op: <Id.Arith_Plus _>
                                        left: (Var SG)
                                        right: (Const Id.Expr_DecInt 1)
                                      )
                                  )
                                }
                              spids: [1267]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:CHEF)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: (C {($ Id.VSub_DollarName '$SSH')} {(DQ <'which chef-client'>)})
                              )
                            }
                          spids: [1280]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {(DQ ($ Id.VSub_DollarName '$CHEF'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ ($ Id.VSub_DollarName '$HOST') 
                                  <
' doesn\'t seem to have chef installed so probably hasn\'t been assigned a role'
                                  >
                                )
                              }
                            )
                            (C {<echo>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Continue continue>
                            )
                          ]
                          spids: [1292 1305]
                        )
                      ]
                    )
                    (C {($ Id.VSub_DollarName '$SSH')} 
                      {
                        (DQ 
                          <
'grep -m1 server /etc/ntp.conf | cut -f2 -d\' \' > /tmp/clusterjunk.txt '
                          >
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:DNS)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (C {($ Id.VSub_DollarName '$SSH')} 
                                    {(DQ <'cat /tmp/clusterjunk.txt | xargs -n1 host'>)}
                                  )
                              )
                            }
                          spids: [1346]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {(DQ ($ Id.VSub_DollarName '$DNS'))}
                                          right: {(DQ <'not found'>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<echo>} {(DQ ($ Id.VSub_DollarName '$DNS') <' !!WARNING!!'>)})]
                          spids: [1358 1375]
                        )
                      ]
                      else_action: [
                        (C {<vtrace>} {(DQ ($ Id.VSub_DollarName '$DNS'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:NTP)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_Backtick '`'>
                                    child: 
                                      (C {($ Id.VSub_DollarName '$SSH')} 
                                        {
                                          (DQ 
                                            <
'cat /tmp/clusterjunk.txt | xargs -n1 ping -c 1 | grep ttl | cut -f4 -d\' \' | cut -f1 -d:'
                                            >
                                          )
                                        }
                                      )
                                  )
                                }
                              spids: [1410]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_z
                                              child: {(DQ ($ Id.VSub_DollarName '$NTP'))}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [
                                (C {<echo>} {(DQ <'timeserver couldn\'t be pinged !!WARNING!!'>)})
                              ]
                              spids: [1422 1435]
                            )
                          ]
                          else_action: [
                            (C {<vtrace>} 
                              {(DQ <'timeserver pinged ok : '> ($ Id.VSub_DollarName '$NTP'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:TIME)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (C {<'./nodessh.sh'>} {($ Id.VSub_DollarName '$ENVIRONMENT')} 
                                            {($ Id.VSub_DollarName '$HOST')} {(DQ <'cat /tmp/clusterjunk.txt | xargs -n1 ntpdate -q -p1'>)}
                                          )
                                      )
                                    }
                                  spids: [1466]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.LogicalNot
                                                  child: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_EqualTilde
                                                      left: {(DQ ($ Id.VSub_DollarName '$TIME'))}
                                                      right: {(DQ <'time server'>)}
                                                    )
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<echo>} {(DQ <'timeserver couldn\'t be used !!WARNING!!'>)})
                                  ]
                                  spids: [1482 1500]
                                )
                              ]
                              else_action: [
                                (C {<vtrace>} 
                                  {(DQ <'timeserver queried ok : '> ($ Id.VSub_DollarName '$TIME'))}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:STAT)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (C {($ Id.VSub_DollarName '$SSH')} {(DQ <'ceph -s | grep HEALTH'>)})
                              )
                            }
                          spids: [1532]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:STAT)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (C {<echo>} {($ Id.VSub_DollarName '$STAT')})
                                      (C {<cut>} {<-f2>} {<-d> <Id.Lit_Colon ':'>})
                                    ]
                                    negated: F
                                  )
                              )
                            }
                          spids: [1544]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {(DQ ($ Id.VSub_DollarName '$STAT'))}
                                          right: {(DQ <HEALTH_OK>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:STAT)
                                  op: assign_op.Equal
                                  rhs: {(DQ <healthy>)}
                                  spids: [1591]
                                )
                              ]
                            )
                          ]
                          spids: [1563 1580]
                        )
                      ]
                    )
                    (C {<vftrace>} 
                      {
                        (DQ ($ Id.VSub_DollarName '$HOST') <' %20s %s'> <Id.Lit_BadBackslash '\\'> <n>)
                      } {<ceph>} {(DQ ($ Id.VSub_DollarName '$STAT'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:SERVICE)
                          op: assign_op.Equal
                          rhs: {(DQ <fluentd>)}
                          spids: [1656]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:FLUENTD)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (C {($ Id.VSub_DollarName '$SSH')} 
                                    {
                                      (DQ 
                                        <
'ps w -C ruby -C td-agent --no-heading | grep -v chef-client'
                                        >
                                      )
                                    }
                                  )
                              )
                            }
                          spids: [1662]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:STAT)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (C {($ Id.VSub_DollarName '$SSH')} 
                                    {
                                      (DQ 
                                        <
'ps w -C ruby -C td-agent --no-heading | grep -v chef-client | wc -l'
                                        >
                                      )
                                    }
                                  )
                              )
                            }
                          spids: [1674]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:STAT)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (C {<echo>} {($ Id.VSub_DollarName '$STAT')})
                                      (C {<cut>} {<-f2>} {<-d> <Id.Lit_Colon ':'>})
                                    ]
                                    negated: F
                                  )
                              )
                            }
                          spids: [1686]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {(DQ ($ Id.VSub_DollarName '$STAT'))}
                                          right: {<2>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:STAT)
                                  op: assign_op.Equal
                                  rhs: {(DQ <' normal'>)}
                                  spids: [1724]
                                )
                              ]
                            )
                          ]
                          spids: [1706 1721]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:STAT)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$FLUENTD'))}
                              spids: [1733]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<vftrace>} 
                      {
                        (DQ ($ Id.VSub_DollarName '$HOST') <' %20s %s'> <Id.Lit_BadBackslash '\\'> <n>)
                      } {(DQ ($ Id.VSub_DollarName '$SERVICE'))} {(DQ ($ Id.VSub_DollarName '$STAT'))}
                    )
                    (command.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: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:STAT)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (C {($ Id.VSub_DollarName '$SSH')} 
                                            {
                                              (DQ <'service '> ($ Id.VSub_DollarName '$SERVICE') 
                                                <' status 2>&1'>
                                              )
                                            }
                                          )
                                      )
                                    }
                                  spids: [1808]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.LogicalNot
                                                  child: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_EqualTilde
                                                      left: {(DQ ($ Id.VSub_DollarName '$STAT'))}
                                                      right: {(DQ <unrecognized>)}
                                                    )
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobEqual
                                                          left: 
                                                            {(DQ ($ Id.VSub_DollarName '$SERVICE'))}
                                                          right: {(DQ <apache2>)}
                                                        )
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.Simple
                                              words: [
                                                {<wget>}
                                                {<http> <Id.Lit_Colon ':'> <'//'> 
                                                  ($ Id.VSub_DollarName '$HOST')
                                                }
                                                {<-O->}
                                                {<-t1>}
                                                {<-T1>}
                                              ]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Great '>'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: {<'/dev/null'>}
                                                )
                                                (redir
                                                  op: <Id.Redir_GreatAnd '2>&'>
                                                  loc: (redir_loc.Fd fd:2)
                                                  arg: {<1>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.Sentence
                                                          child: 
                                                            (command.DBracket
                                                              expr: 
                                                                (bool_expr.Binary
                                                                  op_id: Id.BoolBinary_GlobNEqual
                                                                  left: {(DQ ($ Id.VSub_QMark '$?'))}
                                                                  right: {<0>}
                                                                )
                                                            )
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:STAT)
                                                          op: assign_op.Equal
                                                          rhs: {(DQ <' !! not responding !!'>)}
                                                          spids: [1930]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [1912 1927]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:STAT)
                                                      op: assign_op.Equal
                                                      rhs: {(DQ <' responding'>)}
                                                      spids: [1939]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [1860 1877]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:STAT)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Id.Left_Backtick '`'>
                                                    child: 
                                                      (command.Pipeline
                                                        children: [
                                                          (C {<echo>} {($ Id.VSub_DollarName '$STAT')})
                                                          (C {<cut>} {<-f2>} {<-d> (DQ <':'>)})
                                                        ]
                                                        negated: F
                                                      )
                                                  )
                                                }
                                              spids: [1955]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.LogicalAnd
                                                          left: 
                                                            (bool_expr.LogicalNot
                                                              child: 
                                                                (bool_expr.Binary
                                                                  op_id: Id.BoolBinary_EqualTilde
                                                                  left: 
                                                                    {
                                                                      (DQ 
                                                                        ($ Id.VSub_DollarName '$STAT')
                                                                      )
                                                                    }
                                                                  right: {(DQ <'start/running'>)}
                                                                )
                                                            )
                                                          right: 
                                                            (bool_expr.LogicalAnd
                                                              left: 
                                                                (bool_expr.LogicalNot
                                                                  child: 
                                                                    (bool_expr.Binary
                                                                      op_id: 
Id.BoolBinary_EqualTilde
                                                                      left: 
                                                                        {
                                                                          (DQ 
                                                                            ($ Id.VSub_DollarName 
'$STAT'
                                                                            )
                                                                          )
                                                                        }
                                                                      right: 
                                                                        {(DQ <'haproxy is running'>)}
                                                                    )
                                                                )
                                                              right: 
                                                                (bool_expr.LogicalNot
                                                                  child: 
                                                                    (bool_expr.Binary
                                                                      op_id: 
Id.BoolBinary_EqualTilde
                                                                      left: 
                                                                        {
                                                                          (DQ 
                                                                            ($ Id.VSub_DollarName 
'$STAT'
                                                                            )
                                                                          )
                                                                        }
                                                                      right: {(DQ <responding>)}
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (C {<printf>} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HOST') <' %20s %s'> 
                                                  <Id.Lit_BadBackslash '\\'> <n>
                                                )
                                              } {(DQ ($ Id.VSub_DollarName '$SERVICE'))} {(DQ ($ Id.VSub_DollarName '$STAT'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:BADHOSTS)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ Id.VSub_DollarName '$BADHOSTS') <' '> 
                                                        ($ Id.VSub_DollarName '$HOST')
                                                      )
                                                    }
                                                  spids: [2053]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [1981 2028]
                                        )
                                      ]
                                      else_action: [
                                        (C {<vftrace>} 
                                          {
                                            (DQ ($ Id.VSub_DollarName '$HOST') <' %20s %s'> 
                                              <Id.Lit_BadBackslash '\\'> <n>
                                            )
                                          } {(DQ ($ Id.VSub_DollarName '$SERVICE'))} {(DQ ($ Id.VSub_DollarName '$STAT'))}
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1822 1841]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobEqual
                                                  left: {(DQ ($ Id.VSub_DollarName '$SERVICE'))}
                                                  right: {(DQ <tpm>)}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:STAT)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_Backtick '`'>
                                                child: 
                                                  (C {($ Id.VSub_DollarName '$SSH')} 
                                                    {
                                                      (DQ 
                                                        <
'cat /proc/sys/kernel/random/entropy_avail'
                                                        >
                                                      )
                                                    }
                                                  )
                                              )
                                            }
                                          spids: [2105]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DParen
                                                      child: 
                                                        (arith_expr.Binary
                                                          op_id: Id.Arith_Less
                                                          left: {(${ Id.VSub_Name STAT)}
                                                          right: {<Id.Lit_Digits 1000>}
                                                        )
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (C {<printf>} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HOST') <' %20s %s'> 
                                                  <Id.Lit_BadBackslash '\\'> <n>
                                                )
                                              } {(DQ ($ Id.VSub_DollarName '$SERVICE'))} {(DQ <'Entropy low ('> ($ Id.VSub_DollarName '$STAT') <')'>)}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:BADHOSTS)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ Id.VSub_DollarName '$BADHOSTS') <' '> 
                                                        ($ Id.VSub_DollarName '$HOST')
                                                      )
                                                    }
                                                  spids: [2154]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [2117 2131]
                                        )
                                      ]
                                      else_action: [
                                        (C {<vftrace>} 
                                          {
                                            (DQ ($ Id.VSub_DollarName '$HOST') <'%20s %s'> 
                                              <Id.Lit_BadBackslash '\\'> <n>
                                            )
                                          } {(DQ ($ Id.VSub_DollarName '$SERVICE'))} {(DQ <'Entropy ok ('> ($ Id.VSub_DollarName '$STAT') <')'>)}
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2085 2102]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {<echo>})
                    (command.Simple
                      words: [
                        {<ssh>}
                        {($ Id.VSub_DollarName '$SSH_COMMAND_OPTS')}
                        {<-O>}
                        {<Id.ControlFlow_Exit exit>}
                        {<ubuntu> <Id.Lit_At '@'> ($ Id.VSub_DollarName '$HOST')}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<'/dev/null'>}
                        )
                        (redir
                          op: <Id.Redir_GreatAnd '2>&'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<1>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                )
            )
          ]
          spids: [464 475]
        )
      ]
      else_action: [(C {<echo>} {(DQ <'Warning \'cluster.txt\' not found'>)})]
    )
    (C {<echo>} 
      {
        (DQ ($ Id.VSub_DollarName '$ENVIRONMENT') <' cluster summary: '> ($ Id.VSub_DollarName '$UP') 
          <' hosts up. '> ($ Id.VSub_DollarName '$MA') <' hosts with default main route. '> ($ Id.VSub_DollarName '$MG') 
          <' hosts with default mgmt route. '> ($ Id.VSub_DollarName '$SG') <' hosts with default storage route'>
        )
      }
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:BADHOSTS)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                child: 
                  (command.Pipeline
                    children: [
                      (C {<echo>} {($ Id.VSub_DollarName '$BADHOSTS')})
                      (C {<uniq>})
                      (C {<sort>})
                    ]
                    negated: F
                  )
              )
            }
          spids: [2247]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.LogicalNot
                          child: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {(DQ ($ Id.VSub_DollarName '$BADHOSTS'))}
                            )
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<echo>} 
              {(DQ <'Bad hosts '> ($ Id.VSub_DollarName '$BADHOSTS') <' - definite issues on these'>)}
            )
          ]
          spids: [2264 2279]
        )
      ]
    )
  ]
)