#!/bin/bash

# Copyright 2015 The Kubernetes Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

set -o errexit
set -o nounset
set -o pipefail

proc grab_profiles_from_component {
  var requested_profiles = $1
  var mem_pprof_flags = $2
  var binary = $3
  var tunnel_port = $4
  var path = $5
  var output_prefix = $6
  var timestamp = $7

  echo "binary: $binary"

  for profile in [$(requested_profiles)] {
    matchstr $(profile) {
      cpu {
        go tool pprof "-pdf" $(binary) "http://localhost:$(tunnel_port)$(path)/debug/pprof/profile" > "$(output_prefix)-$(profile)-profile-$(timestamp).pdf"
        }
      mem {
        # There are different kinds of memory profiles that are available that
        # had to be grabbed separately: --inuse-space, --inuse-objects,
        # --alloc-space, --alloc-objects. We need to iterate over all requested
        # kinds.
        for flag in [$(mem_pprof_flags)] {
          go tool pprof "-$(flag)" "-pdf" $(binary) "http://localhost:$(tunnel_port)$(path)/debug/pprof/heap" > "$(output_prefix)-$(profile)-$(flag)-profile-$(timestamp).pdf"
        }
        }
    }
  }
}

global KUBE_ROOT := "$[dirname $(BASH_SOURCE)]/.."
source "$(KUBE_ROOT)/hack/lib/init.sh"

global server_addr := ''""
global kubelet_addreses := ''""
global kubelet_binary := ''""
global master_binary := ''""
global scheduler_binary := ''""
global scheduler_port := '"10251'"
global controller_manager_port := '"10252'"
global controller_manager_binary := ''""
global requested_profiles := ''""
global mem_pprof_flags := ''""
global profile_components := ''""
global output_dir := '".'"
global tunnel_port := $(tunnel_port:-1234)

global args := $[getopt -o s:mho:k:c -l server:,master,heapster,output:,kubelet:,scheduler,controller-manager,help,inuse-space,inuse-objects,alloc-space,alloc-objects,cpu,kubelet-binary:,master-binary:,scheduler-binary:,controller-manager-binary:,scheduler-port:,controller-manager-port: -- @Argv]
if [[ $? -ne 0 ]] {
  >&2 echo "Error in getopt> !2 echo "Error in getopt"
  exit 1
}

global HEAPSTER_VERSION := '"v0.18.2'"
global MASTER_PPROF_PATH := ''""
global HEAPSTER_PPROF_PATH := '"/api/v1/proxy/namespaces/kube-system/services/monitoring-heapster'"
global KUBELET_PPROF_PATH_PREFIX := '"/api/v1/proxy/nodes'"
global SCHEDULER_PPROF_PATH_PREFIX := '"/api/v1/proxy/namespaces/kube-system/pods/kube-scheduler'"
global CONTROLLER_MANAGER_PPROF_PATH_PREFIX := '"/api/v1/proxy/namespaces/kube-system/pods/kube-controller-manager'"

eval set -- $(args)

while true {
  matchstr $1 {
    -s|--server {
      shift
      if test -z $1 {
        >&2 echo "empty argument to --server flag> !2 echo "empty argument to --server flag"
        exit 1
      }
      global server_addr := $1
      shift
      }
    -m|--master {
      shift
      global profile_components := ""master $(profile_components)""
      }
    --master-binary {
      shift
      if test -z $1 {
        >&2 echo "empty argumet to --master-binary flag> !2 echo "empty argumet to --master-binary flag"
        exit 1
      }
      global master_binary := $1
      shift
      }
    -h|--heapster {
      shift
      global profile_components := ""heapster $(profile_components)""
      }
    -k|--kubelet {
      shift
      global profile_components := ""kubelet $(profile_components)""
      if test -z $1 {
        >&2 echo "empty argumet to --kubelet flag> !2 echo "empty argumet to --kubelet flag"
        exit 1
      }
      global kubelet_addreses := ""$1 $kubelet_addreses""
      shift
      }
    --kubelet-binary {
      shift
      if test -z $1 {
        >&2 echo "empty argumet to --kubelet-binary flag> !2 echo "empty argumet to --kubelet-binary flag"
        exit 1
      }
      global kubelet_binary := $1
      shift
      }
    --scheduler {
      shift
      global profile_components := ""scheduler $(profile_components)""
      }
    --scheduler-binary {
      shift
      if test -z $1 {
        >&2 echo "empty argumet to --scheduler-binary flag> !2 echo "empty argumet to --scheduler-binary flag"
        exit 1
      }
      global scheduler_binary := $1
      shift
      }
    --scheduler-port {
      shift
      if test -z $1 {
        >&2 echo "empty argumet to --scheduler-port flag> !2 echo "empty argumet to --scheduler-port flag"
        exit 1
      }
      global scheduler_port := $1
      shift
      }
    -c|--controller-manager {
      shift
      global profile_components := ""controller-manager $(profile_components)""
      }
    --controller-manager-binary {
      shift
      if test -z $1 {
        >&2 echo "empty argumet to --controller-manager-binary flag> !2 echo "empty argumet to --controller-manager-binary flag"
        exit 1
      }
      global controller_manager_binary := $1
      shift
      }
    --controller-manager-port {
      shift
      if test -z $1 {
        >&2 echo "empty argumet to --controller-manager-port flag> !2 echo "empty argumet to --controller-manager-port flag"
        exit 1
      }
      controller-managerr_port=$1
      shift
      }
    -o|--output {
      shift
      if test -z $1 {
        >&2 echo "empty argument to --output flag> !2 echo "empty argument to --output flag"
        exit 1
      }
      global output_dir := $1
      shift
      }
    --inuse-space {
      shift
      global requested_profiles := ""mem $(requested_profiles)""
      global mem_pprof_flags := ""inuse_space $(mem_pprof_flags)""
      }
    --inuse-objects {
      shift
      global requested_profiles := ""mem $(requested_profiles)""
      global mem_pprof_flags := ""inuse_objects $(mem_pprof_flags)""
      }
    --alloc-space {
      shift
      global requested_profiles := ""mem $(requested_profiles)""
      global mem_pprof_flags := ""alloc_space $(mem_pprof_flags)""
      }
    --alloc-objects {
      shift
      global requested_profiles := ""mem $(requested_profiles)""
      global mem_pprof_flags := ""alloc_objects $(mem_pprof_flags)""
      }
    --cpu {
      shift
      global requested_profiles := ""cpu $(requested_profiles)""
      }
    --help {
      shift
      echo "Recognized options:
        -o/--output,
        -s/--server,
        -m/--master,
        -h/--heapster,
        --inuse-space,
        --inuse-objects,
        --alloc-space,
        --alloc-objects,
        --cpu,
        --help"
      exit 0
      }
    -- {
      shift
      break;
      }
  }
}

if [[ -z "${server_addr}" ]] {
  >&2 echo "Server flag is required> !2 echo "Server flag is required"
  exit 1
}

if [[ -z "${profile_components}" ]] {
  >&2 echo "Choose at least one component to profile> !2 echo "Choose at least one component to profile"
  exit 1
}

if [[ -z "${requested_profiles}" ]] {
  >&2 echo "Choose at least one profiling option> !2 echo "Choose at least one profiling option"
  exit 1
}

gcloud compute ssh $(server_addr) --ssh-flag=-nN --ssh-flag=-L$(tunnel_port):localhost:8080 &

echo "Waiting for tunnel to be created..."
kube::util::wait_for_url http://localhost:$(tunnel_port)/healthz

global SSH_PID := $[pgrep -f "/usr/bin/ssh.*$(tunnel_port):localhost:8080]
kube::util::trap_add 'kill $SSH_PID' EXIT
kube::util::trap_add 'kill $SSH_PID' SIGTERM

global requested_profiles := $[echo $(requested_profiles) | xargs -n1 | env LC_ALL=C sort -u | xargs]
global profile_components := $[echo $(profile_components) | xargs -n1 | env LC_ALL=C sort -u | xargs]
global kubelet_addreses := $[echo $(kubelet_addreses) | xargs -n1 | env LC_ALL=C sort -u | xargs]
echo "requested profiles: $(requested_profiles)"
echo "flags for heap profile: $(mem_pprof_flags)"

global timestamp := $[date +%Y%m%d%H%M%S]
global binary := ''""

for component in [$(profile_components)] {
  matchstr $(component) {
    master {
      global path := $(MASTER_PPROF_PATH)
      global binary := $(master_binary)
      }
    controller-manager {
      global path := ""$(CONTROLLER_MANAGER_PPROF_PATH_PREFIX)-$(server_addr):$(controller_manager_port)""
      global binary := $(controller_manager_binary)
      }
    scheduler {
      global path := ""$(SCHEDULER_PPROF_PATH_PREFIX)-$(server_addr):$(scheduler_port)""
      global binary := $(scheduler_binary)
      }
    heapster {
      rm heapster
      wget https://github.com/kubernetes/heapster/releases/download/$(HEAPSTER_VERSION)/heapster
      kube::util::trap_add 'rm -f heapster' EXIT
      kube::util::trap_add 'rm -f heapster' SIGTERM
      global binary := 'heapster'
      global path := $(HEAPSTER_PPROF_PATH)
      }
    kubelet {
      global path := $(KUBELET_PPROF_PATH_PREFIX)
      if [[ -z "${kubelet_binary}" ]] {
        global binary := ""$(KUBE_ROOT)/_output/local/bin/linux/amd64/kubelet""
      } else {
        global binary := $(kubelet_binary)
      }
      }
  }

  if [[ "${component}" == "kubelet" ]] {
    for node in [$[echo $(kubelet_addreses) | sed 's/[,;]/\n/g]] {
      grab_profiles_from_component $(requested_profiles) $(mem_pprof_flags) $(binary) $(tunnel_port) "$(path)/$(node)" "$(output_dir)/$(component)" $(timestamp)
    }    
  } else { 
    grab_profiles_from_component $(requested_profiles) $(mem_pprof_flags) $(binary) $(tunnel_port) $(path) "$(output_dir)/$(component)" $(timestamp)
  }
}
(CommandList
  children: [
    (C {(set)} {(-o)} {(errexit)})
    (C {(set)} {(-o)} {(nounset)})
    (C {(set)} {(-o)} {(pipefail)})
    (FuncDef
      name: grab_profiles_from_component
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:requested_profiles)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [72]
                )
              ]
              spids: [70]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:mem_pprof_flags)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [78]
                )
              ]
              spids: [76]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:binary)
                  op: Equal
                  rhs: {($ VSub_Number "$3")}
                  spids: [84]
                )
              ]
              spids: [82]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:tunnel_port)
                  op: Equal
                  rhs: {($ VSub_Number "$4")}
                  spids: [90]
                )
              ]
              spids: [88]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:path)
                  op: Equal
                  rhs: {($ VSub_Number "$5")}
                  spids: [96]
                )
              ]
              spids: [94]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:output_prefix)
                  op: Equal
                  rhs: {($ VSub_Number "$6")}
                  spids: [102]
                )
              ]
              spids: [100]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:timestamp)
                  op: Equal
                  rhs: {($ VSub_Number "$7")}
                  spids: [108]
                )
              ]
              spids: [106]
            )
            (C {(echo)} {(DQ ("binary: ") ($ VSub_Name "$binary"))})
            (ForEach
              iter_name: profile
              iter_words: [{(${ VSub_Name requested_profiles)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(${ VSub_Name profile)}
                      arms: [
                        (case_arm
                          pat_list: [{(cpu)}]
                          action: [
                            (SimpleCommand
                              words: [
                                {(go)}
                                {(tool)}
                                {(pprof)}
                                {(DQ (-pdf))}
                                {(DQ (${ VSub_Name binary))}
                                {
                                  (DQ ("http://localhost:") (${ VSub_Name tunnel_port) 
                                    (${ VSub_Name path) (/debug/pprof/profile)
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: 
                                    {
                                      (DQ (${ VSub_Name output_prefix) (-) (${ VSub_Name profile) 
                                        (-profile-) (${ VSub_Name timestamp) (.pdf)
                                      )
                                    }
                                  spids: [176]
                                )
                              ]
                            )
                          ]
                          spids: [145 146 194 -1]
                        )
                        (case_arm
                          pat_list: [{(mem)}]
                          action: [
                            (ForEach
                              iter_name: flag
                              iter_words: [{(${ VSub_Name mem_pprof_flags)}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (SimpleCommand
                                      words: [
                                        {(go)}
                                        {(tool)}
                                        {(pprof)}
                                        {(DQ (-) (${ VSub_Name flag))}
                                        {(DQ (-pdf))}
                                        {(DQ (${ VSub_Name binary))}
                                        {
                                          (DQ ("http://localhost:") (${ VSub_Name tunnel_port) 
                                            (${ VSub_Name path) (/debug/pprof/heap)
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: 
                                            {
                                              (DQ (${ VSub_Name output_prefix) (-) 
                                                (${ VSub_Name profile) (-) (${ VSub_Name flag) (-profile-) (${ VSub_Name timestamp) (.pdf)
                                              )
                                            }
                                          spids: [265]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [228 287]
                                )
                              spids: [222 226]
                            )
                          ]
                          spids: [197 198 290 -1]
                        )
                      ]
                      spids: [136 142 293]
                    )
                  ]
                  spids: [133 296]
                )
              spids: [127 131]
            )
          ]
          spids: [67]
        )
      spids: [63 66]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:KUBE_ROOT)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(dirname)} {(DQ (${ VSub_Name BASH_SOURCE))})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [302 310]
              ) (/..)
            }
          spids: [301]
        )
      ]
      spids: [301]
    )
    (C {(source)} {(DQ (${ VSub_Name KUBE_ROOT) (/hack/lib/init.sh))})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:server_addr) op:Equal rhs:{(DQ )} spids:[323])]
      spids: [323]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:kubelet_addreses) op:Equal rhs:{(DQ )} spids:[327])]
      spids: [327]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:kubelet_binary) op:Equal rhs:{(DQ )} spids:[331])]
      spids: [331]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:master_binary) op:Equal rhs:{(DQ )} spids:[335])]
      spids: [335]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:scheduler_binary) op:Equal rhs:{(DQ )} spids:[339])]
      spids: [339]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:scheduler_port) op:Equal rhs:{(DQ (10251))} spids:[343])]
      spids: [343]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:controller_manager_port)
          op: Equal
          rhs: {(DQ (10252))}
          spids: [348]
        )
      ]
      spids: [348]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:controller_manager_binary)
          op: Equal
          rhs: {(DQ )}
          spids: [353]
        )
      ]
      spids: [353]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:requested_profiles) op:Equal rhs:{(DQ )} spids:[357])]
      spids: [357]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:mem_pprof_flags) op:Equal rhs:{(DQ )} spids:[361])]
      spids: [361]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:profile_components) op:Equal rhs:{(DQ )} spids:[365])]
      spids: [365]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:output_dir) op:Equal rhs:{(DQ (.))} spids:[369])]
      spids: [369]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:tunnel_port)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name tunnel_port>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(1234)})
                  spids: [376 380]
                )
              )
            }
          spids: [374]
        )
      ]
      spids: [374]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:args)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(getopt)} {(-o)} 
                        {(s) (Lit_Other ":") (mho) (Lit_Other ":") (k) (Lit_Other ":") (c)} {(-l)} 
                        {(server) (Lit_Other ":") (Lit_Comma ",") (master) (Lit_Comma ",") (heapster) 
                          (Lit_Comma ",") (output) (Lit_Other ":") (Lit_Comma ",") (kubelet) (Lit_Other ":") (Lit_Comma ",") (scheduler) 
                          (Lit_Comma ",") (controller-manager) (Lit_Comma ",") (help) (Lit_Comma ",") (inuse-space) (Lit_Comma ",") (inuse-objects) 
                          (Lit_Comma ",") (alloc-space) (Lit_Comma ",") (alloc-objects) (Lit_Comma ",") (cpu) (Lit_Comma ",") (kubelet-binary) 
                          (Lit_Other ":") (Lit_Comma ",") (master-binary) (Lit_Other ":") (Lit_Comma ",") (scheduler-binary) (Lit_Other ":") 
                          (Lit_Comma ",") (controller-manager-binary) (Lit_Other ":") (Lit_Comma ",") (scheduler-port) (Lit_Other ":") 
                          (Lit_Comma ",") (controller-manager-port) (Lit_Other ":")
                        } {(--)} {(DQ ($ VSub_At "$@"))}
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [385 452]
              )
            }
          spids: [384]
        )
      ]
      spids: [384]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: (BoolBinary op_id:BoolBinary_ne left:{($ VSub_QMark "$?")} right:{(0)})
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [{(echo)} {(DQ ("Error in getopt"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[470])]
            )
            (C {(exit)} {(1)})
          ]
          spids: [-1 467]
        )
      ]
      spids: [-1 484]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:HEAPSTER_VERSION)
          op: Equal
          rhs: {(DQ (v0.18.2))}
          spids: [487]
        )
      ]
      spids: [487]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:MASTER_PPROF_PATH) op:Equal rhs:{(DQ )} spids:[492])]
      spids: [492]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:HEAPSTER_PPROF_PATH)
          op: Equal
          rhs: {(DQ (/api/v1/proxy/namespaces/kube-system/services/monitoring-heapster))}
          spids: [496]
        )
      ]
      spids: [496]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:KUBELET_PPROF_PATH_PREFIX)
          op: Equal
          rhs: {(DQ (/api/v1/proxy/nodes))}
          spids: [501]
        )
      ]
      spids: [501]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:SCHEDULER_PPROF_PATH_PREFIX)
          op: Equal
          rhs: {(DQ (/api/v1/proxy/namespaces/kube-system/pods/kube-scheduler))}
          spids: [506]
        )
      ]
      spids: [506]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CONTROLLER_MANAGER_PPROF_PATH_PREFIX)
          op: Equal
          rhs: {(DQ (/api/v1/proxy/namespaces/kube-system/pods/kube-controller-manager))}
          spids: [511]
        )
      ]
      spids: [511]
    )
    (C {(eval)} {(set)} {(--)} {(DQ (${ VSub_Name args))})
    (While
      cond: [(Sentence child:(C {(true)}) terminator:<Op_Semi ";">)]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {($ VSub_Number "$1")}
              arms: [
                (case_arm
                  pat_list: [{(-s)} {(--server)}]
                  action: [
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("empty argument to --server flag"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [570]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 567]
                        )
                      ]
                      spids: [-1 585]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:server_addr)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [588]
                        )
                      ]
                      spids: [588]
                    )
                    (C {(shift)})
                  ]
                  spids: [545 548 595 -1]
                )
                (case_arm
                  pat_list: [{(-m)} {(--master)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:profile_components)
                          op: Equal
                          rhs: {(DQ ("master ") (${ VSub_Name profile_components))}
                          spids: [607]
                        )
                      ]
                      spids: [607]
                    )
                  ]
                  spids: [598 601 616 -1]
                )
                (case_arm
                  pat_list: [{(--master-binary)}]
                  action: [
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("empty argumet to --master-binary flag"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [642]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 639]
                        )
                      ]
                      spids: [-1 657]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:master_binary)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [660]
                        )
                      ]
                      spids: [660]
                    )
                    (C {(shift)})
                  ]
                  spids: [619 620 667 -1]
                )
                (case_arm
                  pat_list: [{(-h)} {(--heapster)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:profile_components)
                          op: Equal
                          rhs: {(DQ ("heapster ") (${ VSub_Name profile_components))}
                          spids: [679]
                        )
                      ]
                      spids: [679]
                    )
                  ]
                  spids: [670 673 688 -1]
                )
                (case_arm
                  pat_list: [{(-k)} {(--kubelet)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:profile_components)
                          op: Equal
                          rhs: {(DQ ("kubelet ") (${ VSub_Name profile_components))}
                          spids: [700]
                        )
                      ]
                      spids: [700]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("empty argumet to --kubelet flag"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [725]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 722]
                        )
                      ]
                      spids: [-1 740]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:kubelet_addreses)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$1") (" ") ($ VSub_Name "$kubelet_addreses"))}
                          spids: [743]
                        )
                      ]
                      spids: [743]
                    )
                    (C {(shift)})
                  ]
                  spids: [691 694 754 -1]
                )
                (case_arm
                  pat_list: [{(--kubelet-binary)}]
                  action: [
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("empty argumet to --kubelet-binary flag"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [780]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 777]
                        )
                      ]
                      spids: [-1 795]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:kubelet_binary)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [798]
                        )
                      ]
                      spids: [798]
                    )
                    (C {(shift)})
                  ]
                  spids: [757 758 805 -1]
                )
                (case_arm
                  pat_list: [{(--scheduler)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:profile_components)
                          op: Equal
                          rhs: {(DQ ("scheduler ") (${ VSub_Name profile_components))}
                          spids: [815]
                        )
                      ]
                      spids: [815]
                    )
                  ]
                  spids: [808 809 824 -1]
                )
                (case_arm
                  pat_list: [{(--scheduler-binary)}]
                  action: [
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("empty argumet to --scheduler-binary flag"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [850]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 847]
                        )
                      ]
                      spids: [-1 865]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:scheduler_binary)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [868]
                        )
                      ]
                      spids: [868]
                    )
                    (C {(shift)})
                  ]
                  spids: [827 828 875 -1]
                )
                (case_arm
                  pat_list: [{(--scheduler-port)}]
                  action: [
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("empty argumet to --scheduler-port flag"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [901]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 898]
                        )
                      ]
                      spids: [-1 916]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:scheduler_port)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [919]
                        )
                      ]
                      spids: [919]
                    )
                    (C {(shift)})
                  ]
                  spids: [878 879 926 -1]
                )
                (case_arm
                  pat_list: [{(-c)} {(--controller-manager)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:profile_components)
                          op: Equal
                          rhs: {(DQ ("controller-manager ") (${ VSub_Name profile_components))}
                          spids: [938]
                        )
                      ]
                      spids: [938]
                    )
                  ]
                  spids: [929 932 947 -1]
                )
                (case_arm
                  pat_list: [{(--controller-manager-binary)}]
                  action: [
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {(echo)}
                                {(DQ ("empty argumet to --controller-manager-binary flag"))}
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [973]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 970]
                        )
                      ]
                      spids: [-1 988]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:controller_manager_binary)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [991]
                        )
                      ]
                      spids: [991]
                    )
                    (C {(shift)})
                  ]
                  spids: [950 951 998 -1]
                )
                (case_arm
                  pat_list: [{(--controller-manager-port)}]
                  action: [
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {(echo)}
                                {(DQ ("empty argumet to --controller-manager-port flag"))}
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [1024]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 1021]
                        )
                      ]
                      spids: [-1 1039]
                    )
                    (C {(controller-managerr_port) (Lit_Other "=") ($ VSub_Number "$1")})
                    (C {(shift)})
                  ]
                  spids: [1001 1002 1050 -1]
                )
                (case_arm
                  pat_list: [{(-o)} {(--output)}]
                  action: [
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("empty argument to --output flag"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [1078]
                                )
                              ]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 1075]
                        )
                      ]
                      spids: [-1 1093]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:output_dir)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1096]
                        )
                      ]
                      spids: [1096]
                    )
                    (C {(shift)})
                  ]
                  spids: [1053 1056 1103 -1]
                )
                (case_arm
                  pat_list: [{(--inuse-space)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:requested_profiles)
                          op: Equal
                          rhs: {(DQ ("mem ") (${ VSub_Name requested_profiles))}
                          spids: [1113]
                        )
                      ]
                      spids: [1113]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:mem_pprof_flags)
                          op: Equal
                          rhs: {(DQ ("inuse_space ") (${ VSub_Name mem_pprof_flags))}
                          spids: [1122]
                        )
                      ]
                      spids: [1122]
                    )
                  ]
                  spids: [1106 1107 1131 -1]
                )
                (case_arm
                  pat_list: [{(--inuse-objects)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:requested_profiles)
                          op: Equal
                          rhs: {(DQ ("mem ") (${ VSub_Name requested_profiles))}
                          spids: [1141]
                        )
                      ]
                      spids: [1141]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:mem_pprof_flags)
                          op: Equal
                          rhs: {(DQ ("inuse_objects ") (${ VSub_Name mem_pprof_flags))}
                          spids: [1150]
                        )
                      ]
                      spids: [1150]
                    )
                  ]
                  spids: [1134 1135 1159 -1]
                )
                (case_arm
                  pat_list: [{(--alloc-space)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:requested_profiles)
                          op: Equal
                          rhs: {(DQ ("mem ") (${ VSub_Name requested_profiles))}
                          spids: [1169]
                        )
                      ]
                      spids: [1169]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:mem_pprof_flags)
                          op: Equal
                          rhs: {(DQ ("alloc_space ") (${ VSub_Name mem_pprof_flags))}
                          spids: [1178]
                        )
                      ]
                      spids: [1178]
                    )
                  ]
                  spids: [1162 1163 1187 -1]
                )
                (case_arm
                  pat_list: [{(--alloc-objects)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:requested_profiles)
                          op: Equal
                          rhs: {(DQ ("mem ") (${ VSub_Name requested_profiles))}
                          spids: [1197]
                        )
                      ]
                      spids: [1197]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:mem_pprof_flags)
                          op: Equal
                          rhs: {(DQ ("alloc_objects ") (${ VSub_Name mem_pprof_flags))}
                          spids: [1206]
                        )
                      ]
                      spids: [1206]
                    )
                  ]
                  spids: [1190 1191 1215 -1]
                )
                (case_arm
                  pat_list: [{(--cpu)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:requested_profiles)
                          op: Equal
                          rhs: {(DQ ("cpu ") (${ VSub_Name requested_profiles))}
                          spids: [1225]
                        )
                      ]
                      spids: [1225]
                    )
                  ]
                  spids: [1218 1219 1234 -1]
                )
                (case_arm
                  pat_list: [{(--help)}]
                  action: [
                    (C {(shift)})
                    (C {(echo)} 
                      {
                        (DQ ("Recognized options:\n") ("        -o/--output,\n") 
                          ("        -s/--server,\n") ("        -m/--master,\n") ("        -h/--heapster,\n") ("        --inuse-space,\n") 
                          ("        --inuse-objects,\n") ("        --alloc-space,\n") ("        --alloc-objects,\n") ("        --cpu,\n") ("        --help")
                        )
                      }
                    )
                    (C {(exit)} {(0)})
                  ]
                  spids: [1237 1238 1266 -1]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [
                    (C {(shift)})
                    (Sentence
                      child: (ControlFlow token:<ControlFlow_Break break>)
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [1269 1270 1280 -1]
                )
              ]
              spids: [538 542 1283]
            )
          ]
          spids: [535 1285]
        )
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: (BoolUnary op_id:BoolUnary_z child:{(DQ (${ VSub_Name server_addr))})
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [{(echo)} {(DQ ("Server flag is required"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1306])]
            )
            (C {(exit)} {(1)})
          ]
          spids: [-1 1303]
        )
      ]
      spids: [-1 1320]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: (BoolUnary op_id:BoolUnary_z child:{(DQ (${ VSub_Name profile_components))})
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [{(echo)} {(DQ ("Choose at least one component to profile"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1341])]
            )
            (C {(exit)} {(1)})
          ]
          spids: [-1 1338]
        )
      ]
      spids: [-1 1355]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: (BoolUnary op_id:BoolUnary_z child:{(DQ (${ VSub_Name requested_profiles))})
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [{(echo)} {(DQ ("Choose at least one profiling option"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1376])]
            )
            (C {(exit)} {(1)})
          ]
          spids: [-1 1373]
        )
      ]
      spids: [-1 1390]
    )
    (Sentence
      child: 
        (C {(gcloud)} {(compute)} {(ssh)} {(DQ (${ VSub_Name server_addr))} 
          {(--ssh-flag) (Lit_Other "=") (-nN)} 
          {(--ssh-flag) (Lit_Other "=") (-L) (${ VSub_Name tunnel_port) (Lit_Other ":") (localhost) 
            (Lit_Other ":") (8080)
          }
        )
      terminator: <Op_Amp "&">
    )
    (C {(echo)} {(DQ ("Waiting for tunnel to be created..."))})
    (C {(kube) (Lit_Other ":") (Lit_Other ":") (util) (Lit_Other ":") (Lit_Other ":") (wait_for_url)} 
      {(http) (Lit_Other ":") (//localhost) (Lit_Other ":") (${ VSub_Name tunnel_port) (/healthz)}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:SSH_PID)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(pgrep)} {(-f)} 
                        {(DQ ("/usr/bin/ssh.*") (${ VSub_Name tunnel_port) (":localhost:8080"))}
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1448 1460]
              )
            }
          spids: [1447]
        )
      ]
      spids: [1447]
    )
    (C {(kube) (Lit_Other ":") (Lit_Other ":") (util) (Lit_Other ":") (Lit_Other ":") (trap_add)} 
      {(SQ <"kill $SSH_PID">)} {(EXIT)}
    )
    (C {(kube) (Lit_Other ":") (Lit_Other ":") (util) (Lit_Other ":") (Lit_Other ":") (trap_add)} 
      {(SQ <"kill $SSH_PID">)} {(SIGTERM)}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:requested_profiles)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(echo)} {(${ VSub_Name requested_profiles)})
                          (C {(xargs)} {(-n1)})
                          (SimpleCommand
                            words: [{(sort)} {(-u)}]
                            more_env: [(env_pair name:LC_ALL val:{(C)} spids:[1507])]
                          )
                          (C {(xargs)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1492 1517]
              )
            }
          spids: [1491]
        )
      ]
      spids: [1491]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:profile_components)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(echo)} {(${ VSub_Name profile_components)})
                          (C {(xargs)} {(-n1)})
                          (SimpleCommand
                            words: [{(sort)} {(-u)}]
                            more_env: [(env_pair name:LC_ALL val:{(C)} spids:[1535])]
                          )
                          (C {(xargs)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1520 1545]
              )
            }
          spids: [1519]
        )
      ]
      spids: [1519]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:kubelet_addreses)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(echo)} {(${ VSub_Name kubelet_addreses)})
                          (C {(xargs)} {(-n1)})
                          (SimpleCommand
                            words: [{(sort)} {(-u)}]
                            more_env: [(env_pair name:LC_ALL val:{(C)} spids:[1563])]
                          )
                          (C {(xargs)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1548 1573]
              )
            }
          spids: [1547]
        )
      ]
      spids: [1547]
    )
    (C {(echo)} {(DQ ("requested profiles: ") (${ VSub_Name requested_profiles))})
    (C {(echo)} {(DQ ("flags for heap profile: ") (${ VSub_Name mem_pprof_flags))})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:timestamp)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(date)} 
                        {(Lit_Other "+") (Lit_Other "%") (Y) (Lit_Other "%") (m) (Lit_Other "%") (d) 
                          (Lit_Other "%") (H) (Lit_Other "%") (M) (Lit_Other "%") (S)
                        }
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1595 1611]
              )
            }
          spids: [1594]
        )
      ]
      spids: [1594]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:binary) op:Equal rhs:{(DQ )} spids:[1613])]
      spids: [1613]
    )
    (ForEach
      iter_name: component
      iter_words: [{(${ VSub_Name profile_components)}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(${ VSub_Name component)}
              arms: [
                (case_arm
                  pat_list: [{(master)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:path)
                          op: Equal
                          rhs: {(${ VSub_Name MASTER_PPROF_PATH)}
                          spids: [1645]
                        )
                      ]
                      spids: [1645]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:binary)
                          op: Equal
                          rhs: {(${ VSub_Name master_binary)}
                          spids: [1651]
                        )
                      ]
                      spids: [1651]
                    )
                  ]
                  spids: [1641 1642 1657 -1]
                )
                (case_arm
                  pat_list: [{(controller-manager)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:path)
                          op: Equal
                          rhs: 
                            {
                              (DQ (${ VSub_Name CONTROLLER_MANAGER_PPROF_PATH_PREFIX) (-) 
                                (${ VSub_Name server_addr) (":") (${ VSub_Name controller_manager_port)
                              )
                            }
                          spids: [1664]
                        )
                      ]
                      spids: [1664]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:binary)
                          op: Equal
                          rhs: {(${ VSub_Name controller_manager_binary)}
                          spids: [1680]
                        )
                      ]
                      spids: [1680]
                    )
                  ]
                  spids: [1660 1661 1686 -1]
                )
                (case_arm
                  pat_list: [{(scheduler)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:path)
                          op: Equal
                          rhs: 
                            {
                              (DQ (${ VSub_Name SCHEDULER_PPROF_PATH_PREFIX) (-) 
                                (${ VSub_Name server_addr) (":") (${ VSub_Name scheduler_port)
                              )
                            }
                          spids: [1693]
                        )
                      ]
                      spids: [1693]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:binary)
                          op: Equal
                          rhs: {(${ VSub_Name scheduler_binary)}
                          spids: [1709]
                        )
                      ]
                      spids: [1709]
                    )
                  ]
                  spids: [1689 1690 1715 -1]
                )
                (case_arm
                  pat_list: [{(heapster)}]
                  action: [
                    (C {(rm)} {(heapster)})
                    (C {(wget)} 
                      {(https) (Lit_Other ":") (//github.com/kubernetes/heapster/releases/download/) 
                        (${ VSub_Name HEAPSTER_VERSION) (/heapster)
                      }
                    )
                    (C 
                      {(kube) (Lit_Other ":") (Lit_Other ":") (util) (Lit_Other ":") (Lit_Other ":") 
                        (trap_add)
                      } {(SQ <"rm -f heapster">)} {(EXIT)}
                    )
                    (C 
                      {(kube) (Lit_Other ":") (Lit_Other ":") (util) (Lit_Other ":") (Lit_Other ":") 
                        (trap_add)
                      } {(SQ <"rm -f heapster">)} {(SIGTERM)}
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:binary)
                          op: Equal
                          rhs: {(heapster)}
                          spids: [1768]
                        )
                      ]
                      spids: [1768]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:path)
                          op: Equal
                          rhs: {(${ VSub_Name HEAPSTER_PPROF_PATH)}
                          spids: [1772]
                        )
                      ]
                      spids: [1772]
                    )
                  ]
                  spids: [1718 1719 1778 -1]
                )
                (case_arm
                  pat_list: [{(kubelet)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:path)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name KUBELET_PPROF_PATH_PREFIX))}
                          spids: [1785]
                        )
                      ]
                      spids: [1785]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolUnary
                                      op_id: BoolUnary_z
                                      child: {(DQ (${ VSub_Name kubelet_binary))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:binary)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (${ VSub_Name KUBE_ROOT) 
                                        (/_output/local/bin/linux/amd64/kubelet)
                                      )
                                    }
                                  spids: [1811]
                                )
                              ]
                              spids: [1811]
                            )
                          ]
                          spids: [-1 1808]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:binary)
                              op: Equal
                              rhs: {(${ VSub_Name kubelet_binary)}
                              spids: [1823]
                            )
                          ]
                          spids: [1823]
                        )
                      ]
                      spids: [1820 1829]
                    )
                  ]
                  spids: [1781 1782 1832 -1]
                )
              ]
              spids: [1632 1638 1835]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(DQ (${ VSub_Name component))}
                              right: {(DQ (kubelet))}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (ForEach
                      iter_name: node
                      iter_words: [
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (C {(echo)} {(${ VSub_Name kubelet_addreses)})
                                      (C {(sed)} {(SQ <"s/[,;]/\\n/g">)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1867 1881]
                          )
                        }
                      ]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (C {(grab_profiles_from_component)} {(DQ (${ VSub_Name requested_profiles))} 
                              {(DQ (${ VSub_Name mem_pprof_flags))} {(DQ (${ VSub_Name binary))} {(DQ (${ VSub_Name tunnel_port))} 
                              {(DQ (${ VSub_Name path) (/) (${ VSub_Name node))} {(DQ (${ VSub_Name output_dir) (/) (${ VSub_Name component))} {(DQ (${ VSub_Name timestamp))}
                            )
                          ]
                          spids: [1884 1940]
                        )
                      spids: [1866 1882]
                    )
                  ]
                  spids: [-1 1858]
                )
              ]
              else_action: [
                (C {(grab_profiles_from_component)} {(DQ (${ VSub_Name requested_profiles))} 
                  {(DQ (${ VSub_Name mem_pprof_flags))} {(DQ (${ VSub_Name binary))} {(DQ (${ VSub_Name tunnel_port))} {(DQ (${ VSub_Name path))} 
                  {(DQ (${ VSub_Name output_dir) (/) (${ VSub_Name component))} {(DQ (${ VSub_Name timestamp))}
                )
              ]
              spids: [1944 1997]
            )
          ]
          spids: [1629 1999]
        )
      spids: [1623 1627]
    )
  ]
)