#!/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.

# Download the flannel, etcd, docker, bridge-utils and K8s binaries automatically 
# and store into binaries directory.
# Run as sudoers only

# author @kevin-wangzefeng

set -o errexit
set -o nounset
set -o pipefailsetconst global FOO = "bar"

readonly ROOT = $[dirname $(BASH_SOURCE)]
source $(ROOT)/config-build.sh

# ensure $RELEASES_DIR is an absolute file path
mkdir -p $(RELEASES_DIR)
global RELEASES_DIR := $[cd $(RELEASES_DIR); pwd]

# get absolute file path of binaries
global BINARY_DIR := "$[cd $(ROOT); pwd]/binaries"

proc clean-up {
  rm -rf $(RELEASES_DIR)
  rm -rf $(BINARY_DIR)
}

proc download-releases {
  rm -rf $(RELEASES_DIR)
  mkdir -p $(RELEASES_DIR)

  echo "Download flannel release v$(FLANNEL_VERSION) ..."
  curl -L $(FLANNEL_DOWNLOAD_URL) -o $(RELEASES_DIR)/flannel.tar.gz

  echo "Download etcd release v$(ETCD_VERSION) ..."
  curl -L $(ETCD_DOWNLOAD_URL) -o $(RELEASES_DIR)/etcd.tar.gz

  echo "Download kubernetes release v$(K8S_VERSION) ..."
  curl -L $(K8S_CLIENT_DOWNLOAD_URL) -o $(RELEASES_DIR)/kubernetes-client-linux-amd64.tar.gz
  curl -L $(K8S_SERVER_DOWNLOAD_URL) -o $(RELEASES_DIR)/kubernetes-server-linux-amd64.tar.gz

  echo "Download docker release v$(DOCKER_VERSION) ..."
  curl -L $(DOCKER_DOWNLOAD_URL) -o $(RELEASES_DIR)/docker.tar.gz
}

proc unpack-releases {
  rm -rf $(BINARY_DIR)
  mkdir -p $(BINARY_DIR)/master/bin
  mkdir -p $(BINARY_DIR)/node/bin

  # flannel
  if [[ -f ${RELEASES_DIR}/flannel.tar.gz ]]  {
    tar xzf $(RELEASES_DIR)/flannel.tar.gz -C $(RELEASES_DIR)
    cp $(RELEASES_DIR)/flanneld $(BINARY_DIR)/master/bin
    cp $(RELEASES_DIR)/flanneld $(BINARY_DIR)/node/bin
  }

  # etcd
  if [[ -f ${RELEASES_DIR}/etcd.tar.gz ]]  {
    tar xzf $(RELEASES_DIR)/etcd.tar.gz -C $(RELEASES_DIR)
    global ETCD := ""etcd-v$(ETCD_VERSION)-linux-amd64""
    cp $(RELEASES_DIR)/$ETCD/etcd \
       $(RELEASES_DIR)/$ETCD/etcdctl $(BINARY_DIR)/master/bin
    cp $(RELEASES_DIR)/$ETCD/etcd \
       $(RELEASES_DIR)/$ETCD/etcdctl $(BINARY_DIR)/node/bin
  }

  # k8s
  if [[ -f ${RELEASES_DIR}/kubernetes-client-linux-amd64.tar.gz ]]  {
    tar xzf $(RELEASES_DIR)/kubernetes-client-linux-amd64.tar.gz -C $(RELEASES_DIR)
    cp $(RELEASES_DIR)/kubernetes/client/bin/kubectl $(BINARY_DIR)
  }

  if [[ -f ${RELEASES_DIR}/kubernetes-server-linux-amd64.tar.gz ]]  {
    tar xzf $(RELEASES_DIR)/kubernetes-server-linux-amd64.tar.gz -C $(RELEASES_DIR)
    cp $(RELEASES_DIR)/kubernetes/server/bin/kube-apiserver \
       $(RELEASES_DIR)/kubernetes/server/bin/kube-controller-manager \
       $(RELEASES_DIR)/kubernetes/server/bin/kube-scheduler $(BINARY_DIR)/master/bin
    cp $(RELEASES_DIR)/kubernetes/server/bin/kubelet \
       $(RELEASES_DIR)/kubernetes/server/bin/kube-proxy $(BINARY_DIR)/node/bin
  }

  # docker
  if [[ -f ${RELEASES_DIR}/docker.tar.gz ]] {
    tar xzf $(RELEASES_DIR)/docker.tar.gz -C $(RELEASES_DIR)

    cp $(RELEASES_DIR)/docker/docker* $(BINARY_DIR)/node/bin
  }

  chmod -R +x $(BINARY_DIR)
  echo "Done! All binaries are stored in $(BINARY_DIR)"
}

proc parse-opt {
  var opt = $(1-)

  matchstr $opt {
    download {
      download-releases
      }
    unpack {
      unpack-releases
      }
    clean {
      clean-up
      }
    all {
      download-releases
      unpack-releases
      }
    * {
      echo "Usage: "
      echo "   build.sh <command>"
      echo "Commands:"
      echo "   clean      Clean up downloaded releases and unpacked binaries."
      echo "   download   Download releases to \"$(RELEASES_DIR)\"."
      echo "   unpack     Unpack releases downloaded in \"$(RELEASES_DIR)\", and copy binaries to \"$(BINARY_DIR)\"."
      echo "   all        Download releases and unpack them."
      }
  }
}

parse-opt $ifsjoin(Argv)
(CommandList
  children: [
    (C {(set)} {(-o)} {(errexit)})
    (C {(set)} {(-o)} {(nounset)})
    (C {(set)} {(-o)} {(pipefail)})
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:ROOT)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(dirname)} {(DQ (${ VSub_Name BASH_SOURCE))})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [80 88]
              )
            }
          spids: [79]
        )
      ]
      spids: [77]
    )
    (C {(source)} {(${ VSub_Name ROOT) (/config-build.sh)})
    (C {(mkdir)} {(-p)} {(${ VSub_Name RELEASES_DIR)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:RELEASES_DIR)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Sentence
                        child: (C {(cd)} {(${ VSub_Name RELEASES_DIR)})
                        terminator: <Op_Semi ";">
                      )
                      (C {(pwd)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [110 119]
              )
            }
          spids: [109]
        )
      ]
      spids: [109]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:BINARY_DIR)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Sentence
                        child: (C {(cd)} {(${ VSub_Name ROOT)})
                        terminator: <Op_Semi ";">
                      )
                      (C {(pwd)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [126 135]
              ) (/binaries)
            }
          spids: [125]
        )
      ]
      spids: [125]
    )
    (FuncDef
      name: clean-up
      body: 
        (BraceGroup
          children: [
            (C {(rm)} {(-rf)} {(${ VSub_Name RELEASES_DIR)})
            (C {(rm)} {(-rf)} {(${ VSub_Name BINARY_DIR)})
          ]
          spids: [145]
        )
      spids: [139 144]
    )
    (FuncDef
      name: download-releases
      body: 
        (BraceGroup
          children: [
            (C {(rm)} {(-rf)} {(${ VSub_Name RELEASES_DIR)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name RELEASES_DIR)})
            (C {(echo)} {(DQ ("Download flannel release v") (${ VSub_Name FLANNEL_VERSION) (" ..."))})
            (C {(curl)} {(-L)} {(${ VSub_Name FLANNEL_DOWNLOAD_URL)} {(-o)} 
              {(${ VSub_Name RELEASES_DIR) (/flannel.tar.gz)}
            )
            (C {(echo)} {(DQ ("Download etcd release v") (${ VSub_Name ETCD_VERSION) (" ..."))})
            (C {(curl)} {(-L)} {(${ VSub_Name ETCD_DOWNLOAD_URL)} {(-o)} 
              {(${ VSub_Name RELEASES_DIR) (/etcd.tar.gz)}
            )
            (C {(echo)} {(DQ ("Download kubernetes release v") (${ VSub_Name K8S_VERSION) (" ..."))})
            (C {(curl)} {(-L)} {(${ VSub_Name K8S_CLIENT_DOWNLOAD_URL)} {(-o)} 
              {(${ VSub_Name RELEASES_DIR) (/kubernetes-client-linux-amd64.tar.gz)}
            )
            (C {(curl)} {(-L)} {(${ VSub_Name K8S_SERVER_DOWNLOAD_URL)} {(-o)} 
              {(${ VSub_Name RELEASES_DIR) (/kubernetes-server-linux-amd64.tar.gz)}
            )
            (C {(echo)} {(DQ ("Download docker release v") (${ VSub_Name DOCKER_VERSION) (" ..."))})
            (C {(curl)} {(-L)} {(${ VSub_Name DOCKER_DOWNLOAD_URL)} {(-o)} 
              {(${ VSub_Name RELEASES_DIR) (/docker.tar.gz)}
            )
          ]
          spids: [174]
        )
      spids: [168 173]
    )
    (FuncDef
      name: unpack-releases
      body: 
        (BraceGroup
          children: [
            (C {(rm)} {(-rf)} {(${ VSub_Name BINARY_DIR)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name BINARY_DIR) (/master/bin)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name BINARY_DIR) (/node/bin)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolUnary
                              op_id: BoolUnary_f
                              child: {(${ VSub_Name RELEASES_DIR) (/flannel.tar.gz)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(tar)} {(xzf)} {(${ VSub_Name RELEASES_DIR) (/flannel.tar.gz)} {(-C)} 
                      {(${ VSub_Name RELEASES_DIR)}
                    )
                    (C {(cp)} {(${ VSub_Name RELEASES_DIR) (/flanneld)} 
                      {(${ VSub_Name BINARY_DIR) (/master/bin)}
                    )
                    (C {(cp)} {(${ VSub_Name RELEASES_DIR) (/flanneld)} 
                      {(${ VSub_Name BINARY_DIR) (/node/bin)}
                    )
                  ]
                  spids: [-1 383]
                )
              ]
              spids: [-1 428]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolUnary
                              op_id: BoolUnary_f
                              child: {(${ VSub_Name RELEASES_DIR) (/etcd.tar.gz)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(tar)} {(xzf)} {(${ VSub_Name RELEASES_DIR) (/etcd.tar.gz)} {(-C)} 
                      {(${ VSub_Name RELEASES_DIR)}
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ETCD)
                          op: Equal
                          rhs: {(DQ (etcd-v) (${ VSub_Name ETCD_VERSION) (-linux-amd64))}
                          spids: [470]
                        )
                      ]
                      spids: [470]
                    )
                    (C {(cp)} {(${ VSub_Name RELEASES_DIR) (/) ($ VSub_Name "$ETCD") (/etcd)} 
                      {(${ VSub_Name RELEASES_DIR) (/) ($ VSub_Name "$ETCD") (/etcdctl)} {(${ VSub_Name BINARY_DIR) (/master/bin)}
                    )
                    (C {(cp)} {(${ VSub_Name RELEASES_DIR) (/) ($ VSub_Name "$ETCD") (/etcd)} 
                      {(${ VSub_Name RELEASES_DIR) (/) ($ VSub_Name "$ETCD") (/etcdctl)} {(${ VSub_Name BINARY_DIR) (/node/bin)}
                    )
                  ]
                  spids: [-1 451]
                )
              ]
              spids: [-1 528]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolUnary
                              op_id: BoolUnary_f
                              child: 
                                {(${ VSub_Name RELEASES_DIR) (/kubernetes-client-linux-amd64.tar.gz)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(tar)} {(xzf)} 
                      {(${ VSub_Name RELEASES_DIR) (/kubernetes-client-linux-amd64.tar.gz)} {(-C)} {(${ VSub_Name RELEASES_DIR)}
                    )
                    (C {(cp)} {(${ VSub_Name RELEASES_DIR) (/kubernetes/client/bin/kubectl)} 
                      {(${ VSub_Name BINARY_DIR)}
                    )
                  ]
                  spids: [-1 551]
                )
              ]
              spids: [-1 582]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolUnary
                              op_id: BoolUnary_f
                              child: 
                                {(${ VSub_Name RELEASES_DIR) (/kubernetes-server-linux-amd64.tar.gz)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(tar)} {(xzf)} 
                      {(${ VSub_Name RELEASES_DIR) (/kubernetes-server-linux-amd64.tar.gz)} {(-C)} {(${ VSub_Name RELEASES_DIR)}
                    )
                    (C {(cp)} {(${ VSub_Name RELEASES_DIR) (/kubernetes/server/bin/kube-apiserver)} 
                      {(${ VSub_Name RELEASES_DIR) (/kubernetes/server/bin/kube-controller-manager)} {(${ VSub_Name RELEASES_DIR) (/kubernetes/server/bin/kube-scheduler)} 
                      {(${ VSub_Name BINARY_DIR) (/master/bin)}
                    )
                    (C {(cp)} {(${ VSub_Name RELEASES_DIR) (/kubernetes/server/bin/kubelet)} 
                      {(${ VSub_Name RELEASES_DIR) (/kubernetes/server/bin/kube-proxy)} {(${ VSub_Name BINARY_DIR) (/node/bin)}
                    )
                  ]
                  spids: [-1 601]
                )
              ]
              spids: [-1 667]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolUnary
                              op_id: BoolUnary_f
                              child: {(${ VSub_Name RELEASES_DIR) (/docker.tar.gz)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(tar)} {(xzf)} {(${ VSub_Name RELEASES_DIR) (/docker.tar.gz)} {(-C)} 
                      {(${ VSub_Name RELEASES_DIR)}
                    )
                    (C {(cp)} {(${ VSub_Name RELEASES_DIR) (/docker/docker) (Lit_Other "*")} 
                      {(${ VSub_Name BINARY_DIR) (/node/bin)}
                    )
                  ]
                  spids: [-1 689]
                )
              ]
              spids: [-1 723]
            )
            (C {(chmod)} {(-R)} {(Lit_Other "+") (x)} {(${ VSub_Name BINARY_DIR)})
            (C {(echo)} {(DQ ("Done! All binaries are stored in ") (${ VSub_Name BINARY_DIR))})
          ]
          spids: [331]
        )
      spids: [325 330]
    )
    (FuncDef
      name: parse-opt
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:opt)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Number 1>
                        suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{})
                        spids: [763 766]
                      )
                    }
                  spids: [762]
                )
              ]
              spids: [760]
            )
            (Case
              to_match: {($ VSub_Name "$opt")}
              arms: [
                (case_arm
                  pat_list: [{(download)}]
                  action: [(C {(download-releases)})]
                  spids: [777 778 784 -1]
                )
                (case_arm
                  pat_list: [{(unpack)}]
                  action: [(C {(unpack-releases)})]
                  spids: [787 788 794 -1]
                )
                (case_arm
                  pat_list: [{(clean)}]
                  action: [(C {(clean-up)})]
                  spids: [797 798 804 -1]
                )
                (case_arm
                  pat_list: [{(all)}]
                  action: [(C {(download-releases)}) (C {(unpack-releases)})]
                  spids: [807 808 817 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (C {(echo)} {(DQ ("Usage: "))})
                    (C {(echo)} {(DQ ("   build.sh <command>"))})
                    (C {(echo)} {(DQ ("Commands:"))})
                    (C {(echo)} 
                      {(DQ ("   clean      Clean up downloaded releases and unpacked binaries."))}
                    )
                    (C {(echo)} 
                      {
                        (DQ ("   download   Download releases to ") 
                          (EscapedLiteralPart
                            token: <Lit_EscapedChar "\\\"">
                          ) (${ VSub_Name RELEASES_DIR) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (.)
                        )
                      }
                    )
                    (C {(echo)} 
                      {
                        (DQ ("   unpack     Unpack releases downloaded in ") 
                          (EscapedLiteralPart
                            token: <Lit_EscapedChar "\\\"">
                          ) (${ VSub_Name RELEASES_DIR) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                          (", and copy binaries to ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (${ VSub_Name BINARY_DIR) 
                          (EscapedLiteralPart
                            token: <Lit_EscapedChar "\\\"">
                          ) (.)
                        )
                      }
                    )
                    (C {(echo)} {(DQ ("   all        Download releases and unpack them."))})
                  ]
                  spids: [820 821 891 -1]
                )
              ]
              spids: [770 774 894]
            )
          ]
          spids: [757]
        )
      spids: [751 756]
    )
    (C {(parse-opt)} {($ VSub_At "$@")})
  ]
)