#!/usr/bin/env bash

# Copyright 2014 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.

# Bring up a Kubernetes cluster.
# Usage:
#   wget -q -O - https://get.k8s.io | bash
# or
#   curl -fsSL https://get.k8s.io | bash
#
# Advanced options
#  Set KUBERNETES_PROVIDER to choose between different providers:
#  Google Compute Engine [default]
#   * export KUBERNETES_PROVIDER=gce; wget -q -O - https://get.k8s.io | bash
#  Google Container Engine
#   * export KUBERNETES_PROVIDER=gke; wget -q -O - https://get.k8s.io | bash
#  Amazon EC2
#   * export KUBERNETES_PROVIDER=aws; wget -q -O - https://get.k8s.io | bash
#  Libvirt (with CoreOS as a guest operating system)
#   * export KUBERNETES_PROVIDER=libvirt-coreos; wget -q -O - https://get.k8s.io | bash
#  Microsoft Azure
#   * export KUBERNETES_PROVIDER=azure-legacy; wget -q -O - https://get.k8s.io | bash
#  Vagrant (local virtual machines)
#   * export KUBERNETES_PROVIDER=vagrant; wget -q -O - https://get.k8s.io | bash
#  VMWare Photon Controller
#   * export KUBERNETES_PROVIDER=photon-controller; wget -q -O - https://get.k8s.io | bash
#  OpenStack-Heat
#   * export KUBERNETES_PROVIDER=openstack-heat; wget -q -O - https://get.k8s.io | bash
#
#  Set KUBERNETES_RELEASE to choose a specific release instead of the current
#    stable release, (e.g. 'v1.3.7').
#    See https://github.com/kubernetes/kubernetes/releases for release options.
#  Set KUBERNETES_RELEASE_URL to choose where to download binaries from.
#    (Defaults to https://storage.googleapis.com/kubernetes-release/release).
#
#  Set KUBERNETES_SERVER_ARCH to choose the server (Kubernetes cluster)
#  architecture to download:
#    * amd64 [default]
#    * arm
#    * arm64
#
#  Set KUBERNETES_SKIP_DOWNLOAD to skip downloading a release.
#  Set KUBERNETES_SKIP_CONFIRM to skip the installation confirmation prompt.
#  Set KUBERNETES_SKIP_CREATE_CLUSTER to skip starting a cluster.
#  Set KUBERNETES_SKIP_RELEASE_VALIDATION to skip trying to validate the
#      Kubernetes release string. This implies that you know what you're doing
#      and have set KUBERNETES_RELEASE and KUBERNETES_RELEASE_URL properly.

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

# If KUBERNETES_RELEASE_URL is overridden but KUBERNETES_CI_RELEASE_URL is not then set KUBERNETES_CI_RELEASE_URL to KUBERNETES_RELEASE_URL.
setglobal KUBERNETES_CI_RELEASE_URL = $(KUBERNETES_CI_RELEASE_URL:-${KUBERNETES_RELEASE_URL:-https://dl.k8s.io/ci})
setglobal KUBERNETES_RELEASE_URL = $(KUBERNETES_RELEASE_URL:-https://dl.k8s.io)

setglobal KUBE_RELEASE_VERSION_REGEX = '"^v(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(-([a-zA-Z0-9]+)\\.(0|[1-9][0-9]*))?$'"
setglobal KUBE_CI_VERSION_REGEX = '"^v(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)-([a-zA-Z0-9]+)\\.(0|[1-9][0-9]*)(\\.(0|[1-9][0-9]*)\\+[-0-9a-z]*)?$'"

# Sets KUBE_VERSION variable if an explicit version number was provided (e.g. "v1.0.6",
# "v1.2.0-alpha.1.881+376438b69c7612") or resolves the "published" version
# <path>/<version> (e.g. "release/stable",' "ci/latest-1") by reading from GCS.
#
# See the docs on getting builds for more information about version
# publication.
#
# Args:
#   $1 version string from command line
# Vars set:
#   KUBE_VERSION
proc set_binary_version {
  if [[ "${1}" =~ "/" ]] {
    export KUBE_VERSION=$[curl -fsSL --retry 5 "https://dl.k8s.io/$(1).txt]
  } else {
    export KUBE_VERSION=$(1)
  }
}

# Use the script from inside the Kubernetes tarball to fetch the client and
# server binaries (if not included in kubernetes.tar.gz).
proc download_kube_binaries {
  shell {
    cd kubernetes
    if [[ -x ./cluster/get-kube-binaries.sh ]] {
      # Make sure to use the same download URL in get-kube-binaries.sh
      env KUBERNETES_RELEASE_URL=$(KUBERNETES_RELEASE_URL) \
        ./cluster/get-kube-binaries.sh
    }
  }
}

proc create_cluster {
  if [[ -n "${KUBERNETES_SKIP_CREATE_CLUSTER-}" ]] {
    exit 0
  }
  echo "Creating a kubernetes on $(KUBERNETES_PROVIDER:-gce)..."
  shell {
    cd kubernetes
    ./cluster/kube-up.sh
    echo "Kubernetes binaries at $(PWD)/cluster/"
    if [[ ":$PATH:" != *":${PWD}/cluster:"* ]] {
      echo "You may want to add this directory to your PATH in \$HOME/.profile"
    }

    echo "Installation successful!"
  }
}

if [[ -n "${KUBERNETES_SKIP_DOWNLOAD-}" ]] {
  create_cluster
  exit 0
}

if [[ -d "./kubernetes" ]] {
  if [[ -z "${KUBERNETES_SKIP_CONFIRM-}" ]] {
    echo "'kubernetes' directory already exist. Should we skip download step and start to create cluster based on it? [Y]/n"
    read confirm
    if [[ ! "${confirm}" =~ ^[nN]$ ]] {
      echo "Skipping download step."
      create_cluster
      exit 0
    }
  }
}

# TODO: remove client checks once kubernetes.tar.gz no longer includes client
# binaries by default.
setglobal kernel = $[uname -s]
match $(kernel) {
  with Darwin
    setglobal platform = '"darwin'"
    
  with Linux
    setglobal platform = '"linux'"
    
  with *
    echo "Unknown, unsupported platform: $(kernel)." > !2
    echo "Supported platforms: Linux, Darwin." > !2
    echo "Bailing out." > !2
    exit 2
}

setglobal machine = $[uname -m]
match $(machine) {
  with x86_64*|i?86_64*|amd64*
    setglobal arch = '"amd64'"
    
  with aarch64*|arm64*
    setglobal arch = '"arm64'"
    
  with arm*
    setglobal arch = '"arm'"
    
  with i?86*
    setglobal arch = '"386'"
    
  with *
    echo "Unknown, unsupported architecture ($(machine))." > !2
    echo "Supported architectures x86_64, i686, arm, arm64." > !2
    echo "Bailing out." > !2
    exit 3
    
}

setglobal file = 'kubernetes.tar.gz'
setglobal release = $(KUBERNETES_RELEASE:-"release/stable")

# Validate Kubernetes release version.
# Translate a published version <bucket>/<version> (e.g. "release/stable") to version number.
set_binary_version $(release)
if [[ -z "${KUBERNETES_SKIP_RELEASE_VALIDATION-}" ]] {
  if [[ ${KUBE_VERSION} =~ ${KUBE_CI_VERSION_REGEX} ]] {
    # Override KUBERNETES_RELEASE_URL to point to the CI bucket;
    # this will be used by get-kube-binaries.sh.
    setglobal KUBERNETES_RELEASE_URL = $(KUBERNETES_CI_RELEASE_URL)
  } elif ! [[ ${KUBE_VERSION} =~ ${KUBE_RELEASE_VERSION_REGEX} ]] {
    echo "Version doesn't match regexp" > !2
    exit 1
  }
}
setglobal kubernetes_tar_url = ""$(KUBERNETES_RELEASE_URL)/$(KUBE_VERSION)/$(file)""

setglobal need_download = 'true'
if [[ -r "${PWD}/${file}" ]] {
  setglobal downloaded_version = $[tar -xzOf "$(PWD)/$(file)" kubernetes/version !2 >/dev/null || true]
  echo "Found preexisting $(file), release $(downloaded_version)"
  if [[ "${downloaded_version}" == "${KUBE_VERSION}" ]] {
    echo "Using preexisting kubernetes.tar.gz"
    setglobal need_download = 'false'
  }
}

if $(need_download) {
  echo "Downloading kubernetes release $(KUBE_VERSION)"
  echo "  from $(kubernetes_tar_url)"
  echo "  to $(PWD)/$(file)"
}

if [[ -e "${PWD}/kubernetes" ]] {
  # Let's try not to accidentally nuke something that isn't a kubernetes
  # release dir.
  if [[ ! -f "${PWD}/kubernetes/version" ]] {
    echo "$(PWD)/kubernetes exists but does not look like a Kubernetes release."
    echo "Aborting!"
    exit 5
  }
  echo "Will also delete preexisting 'kubernetes' directory."
}

if [[ -z "${KUBERNETES_SKIP_CONFIRM-}" ]] {
  echo "Is this ok? [Y]/n"
  read confirm
  if [[ "${confirm}" =~ ^[nN]$ ]] {
    echo "Aborting."
    exit 0
  }
}

if $(need_download) {
  if [[ $(which curl) ]] {
    curl -fL --retry 5 --keepalive-time 2 $(kubernetes_tar_url) -o $(file)
  } elif [[ $(which wget) ]] {
    wget $(kubernetes_tar_url)
  } else {
    echo "Couldn't find curl or wget.  Bailing out."
    exit 1
  }
}

echo "Unpacking kubernetes release $(KUBE_VERSION)"
rm -rf "$(PWD)/kubernetes"
tar -xzf $(file)

download_kube_binaries
create_cluster