installers/full_install_osm.sh

   1 #!/bin/bash
   2 #
   3 #   Licensed under the Apache License, Version 2.0 (the "License");
   4 #   you may not use this file except in compliance with the License.
   5 #   You may obtain a copy of the License at
   6 #
   7 #       http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 #   Unless required by applicable law or agreed to in writing, software
  10 #   distributed under the License is distributed on an "AS IS" BASIS,
  11 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 #   See the License for the specific language governing permissions and
  13 #   limitations under the License.
  14 #
  15
  16 function usage(){
  17     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
  18     echo -e "usage: $0 [OPTIONS]"
  19     echo -e "Install OSM"
  20     echo -e "  OPTIONS"
  21     echo -e "     -h / --help:    print this help"
  22     echo -e "     -y:             do not prompt for confirmation, assumes yes"
  23     echo -e "     -r <repo>:      use specified repository name for osm packages"
  24     echo -e "     -R <release>:   use specified release for osm binaries (deb packages, lxd images, ...)"
  25     echo -e "     -u <repo base>: use specified repository url for osm packages"
  26     echo -e "     -k <repo key>:  use specified repository public key url"
  27     echo -e "     -a <apt proxy url>: use this apt proxy url when downloading apt packages (air-gapped installation)"
  28     echo -e "     -c <kubernetes engine>: use a specific kubernetes engine (options: kubeadm, k3s), default is kubeadm"
  29     echo -e "     -s <namespace>  namespace when installed using k8s, default is osm"
  30     echo -e "     -H <VCA host>   use specific juju host controller IP"
  31     echo -e "     -S <VCA secret> use VCA/juju secret key"
  32     echo -e "     -P <VCA pubkey> use VCA/juju public key file"
  33     echo -e "     -A <VCA apiproxy> use VCA/juju API proxy"
  34     echo -e "     --pla:          install the PLA module for placement support"
  35     echo -e "     --old-sa:       install old Service Assurance framework (MON, POL); do not install Airflow and Pushgateway"
  36     echo -e "     --ng-sa:        install new Service Assurance framework (Airflow, AlertManager and Pushgateway) (enabled by default)"
  37     echo -e "     -o <COMPONENT>: ONLY installs the specified component (k8s_monitor, ng-sa, k8scluster, docker, deploy-osm)"
  38     echo -e "     -O <openrc file path/cloud name>: Install OSM to an OpenStack infrastructure. <openrc file/cloud name> is required. If a <cloud name> is used, the clouds.yaml file should be under ~/.config/openstack/ or /etc/openstack/"
  39     echo -e "     -N <openstack public network name/ID>: Public network name required to setup OSM to OpenStack"
  40     echo -e "     -f <path to SSH public key>: Public SSH key to use to deploy OSM to OpenStack"
  41     echo -e "     -F <path to cloud-init file>: Cloud-Init userdata file to deploy OSM to OpenStack"
  42     echo -e "     -D <devops path> use local devops installation path"
  43     echo -e "     -w <work dir>   Location to store runtime installation"
  44     echo -e "     -t <docker tag> specify osm docker tag (default is latest)"
  45     echo -e "     -l:             LXD cloud yaml file"
  46     echo -e "     -L:             LXD credentials yaml file"
  47     echo -e "     -K:             Specifies the name of the controller to use - The controller must be already bootstrapped"
  48     echo -e "     -d <docker registry URL> use docker registry URL instead of dockerhub"
  49     echo -e "     -p <docker proxy URL> set docker proxy URL as part of docker CE configuration"
  50     echo -e "     -T <docker tag> specify docker tag for the modules specified with option -m"
  51     echo -e "     --debug:        debug mode"
  52     echo -e "     --nocachelxdimages:  do not cache local lxd images, do not create cronjob for that cache (will save installation time, might affect instantiation time)"
  53     echo -e "     --cachelxdimages:  cache local lxd images, create cronjob for that cache (will make installation longer)"
  54     echo -e "     --nolxd:        do not install and configure LXD, allowing unattended installations (assumes LXD is already installed and confifured)"
  55     echo -e "     --nodocker:     do not install docker, do not initialize a swarm (assumes docker is already installed and a swarm has been initialized)"
  56     echo -e "     --nojuju:       do not juju, assumes already installed"
  57     echo -e "     --nohostports:  do not expose docker ports to host (useful for creating multiple instances of osm on the same host)"
  58     echo -e "     --nohostclient: do not install the osmclient"
  59     echo -e "     --uninstall:    uninstall OSM: remove the containers and delete NAT rules"
  60     echo -e "     --k8s_monitor:  install the OSM kubernetes monitoring with prometheus and grafana"
  61     echo -e "     --volume:       create a VM volume when installing to OpenStack"
  62     echo -e "     --showopts:     print chosen options and exit (only for debugging)"
  63     echo -e "     --charmed:                   Deploy and operate OSM with Charms on k8s"
  64     echo -e "     [--bundle <bundle path>]:    Specify with which bundle to deploy OSM with charms (--charmed option)"
  65     echo -e "     [--k8s <kubeconfig path>]:   Specify with which kubernetes to deploy OSM with charms (--charmed option)"
  66     echo -e "     [--vca <name>]:              Specifies the name of the controller to use - The controller must be already bootstrapped (--charmed option)"
  67     echo -e "     [--small-profile]:           Do not install and configure LXD which aims to use only K8s Clouds (--charmed option)"
  68     echo -e "     [--lxd <yaml path>]:         Takes a YAML file as a parameter with the LXD Cloud information (--charmed option)"
  69     echo -e "     [--lxd-cred <yaml path>]:    Takes a YAML file as a parameter with the LXD Credentials information (--charmed option)"
  70     echo -e "     [--microstack]:              Installs microstack as a vim. (--charmed option)"
  71     echo -e "     [--overlay]:                 Add an overlay to override some defaults of the default bundle (--charmed option)"
  72     echo -e "     [--ha]:                      Installs High Availability bundle. (--charmed option)"
  73     echo -e "     [--tag]:                     Docker image tag. (--charmed option)"
  74     echo -e "     [--registry]:                Docker registry with optional credentials as user:pass@hostname:port (--charmed option)"
  75     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
  76 }
  77
  78 # takes a juju/accounts.yaml file and returns the password specific
  79 # for a controller. I wrote this using only bash tools to minimize
  80 # additions of other packages
  81 function parse_juju_password {
  82     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
  83     password_file="${HOME}/.local/share/juju/accounts.yaml"
  84     local controller_name=$1
  85     local s='[[:space:]]*' w='[a-zA-Z0-9_-]*' fs=$(echo @|tr @ '\034')
  86     sed -ne "s|^\($s\):|\1|" \
  87          -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
  88          -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p" $password_file |
  89     awk -F$fs -v controller=$controller_name '{
  90         indent = length($1)/2;
  91         vname[indent] = $2;
  92         for (i in vname) {if (i > indent) {delete vname[i]}}
  93         if (length($3) > 0) {
  94             vn=""; for (i=0; i<indent; i++) {vn=(vn)(vname[i])("_")}
  95             if (match(vn,controller) && match($2,"password")) {
  96                 printf("%s",$3);
  97             }
  98         }
  99     }'
 100     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 101 }
 102
 103 function set_vca_variables() {
 104     OSM_VCA_CLOUDNAME="lxd-cloud"
 105     [ -n "$OSM_VCA_HOST" ] && OSM_VCA_CLOUDNAME="localhost"
 106     if [ -z "$OSM_VCA_HOST" ]; then
 107         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`sg lxd -c "juju show-controller $OSM_NAMESPACE"|grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
 108         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`juju show-controller $CONTROLLER_NAME |grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
 109         [ -z "$OSM_VCA_HOST" ] && FATAL "Cannot obtain juju controller IP address"
 110     fi
 111     if [ -z "$OSM_VCA_SECRET" ]; then
 112         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $OSM_NAMESPACE)
 113         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $CONTROLLER_NAME)
 114         [ -z "$OSM_VCA_SECRET" ] && FATAL "Cannot obtain juju secret"
 115     fi
 116     if [ -z "$OSM_VCA_PUBKEY" ]; then
 117         OSM_VCA_PUBKEY=$(cat $HOME/.local/share/juju/ssh/juju_id_rsa.pub)
 118         [ -z "$OSM_VCA_PUBKEY" ] && FATAL "Cannot obtain juju public key"
 119     fi
 120     if [ -z "$OSM_VCA_CACERT" ]; then
 121         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $OSM_NAMESPACE '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
 122         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $CONTROLLER_NAME '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
 123         [ -z "$OSM_VCA_CACERT" ] && FATAL "Cannot obtain juju CA certificate"
 124     fi
 125 }
 126
 127 function generate_secret() {
 128     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 129     head /dev/urandom | tr -dc A-Za-z0-9 | head -c 32
 130     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 131 }
 132
 133 function check_packages() {
 134     NEEDED_PACKAGES="$1"
 135     echo -e "Checking required packages: ${NEEDED_PACKAGES}"
 136     for PACKAGE in ${NEEDED_PACKAGES} ; do
 137         dpkg -L ${PACKAGE}
 138         if [ $? -ne 0 ]; then
 139             echo -e "Package ${PACKAGE} is not installed."
 140             echo -e "Updating apt-cache ..."
 141             sudo apt-get update
 142             echo -e "Installing ${PACKAGE} ..."
 143             sudo apt-get install -y ${PACKAGE} || FATAL "failed to install ${PACKAGE}"
 144         fi
 145     done
 146     echo -e "Required packages are present: ${NEEDED_PACKAGES}"
 147 }
 148
 149 function ask_user(){
 150     # ask to the user and parse a response among 'y', 'yes', 'n' or 'no'. Case insensitive
 151     # Params: $1 text to ask;   $2 Action by default, can be 'y' for yes, 'n' for no, other or empty for not allowed
 152     # Return: true(0) if user type 'yes'; false (1) if user type 'no'
 153     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 154     read -e -p "$1" USER_CONFIRMATION
 155     while true ; do
 156         [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'y' ] && return 0
 157         [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'n' ] && return 1
 158         [ "${USER_CONFIRMATION,,}" == "yes" ] || [ "${USER_CONFIRMATION,,}" == "y" ] && return 0
 159         [ "${USER_CONFIRMATION,,}" == "no" ]  || [ "${USER_CONFIRMATION,,}" == "n" ] && return 1
 160         read -e -p "Please type 'yes' or 'no': " USER_CONFIRMATION
 161     done
 162     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 163 }
 164
 165 function install_osmclient(){
 166     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 167     CLIENT_RELEASE=${RELEASE#"-R "}
 168     CLIENT_REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
 169     CLIENT_REPOSITORY=${REPOSITORY#"-r "}
 170     CLIENT_REPOSITORY_BASE=${REPOSITORY_BASE#"-u "}
 171     key_location=$CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE/$CLIENT_REPOSITORY_KEY
 172     curl $key_location | sudo APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE=1 apt-key add -
 173     sudo add-apt-repository -y "deb [arch=amd64] $CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE $CLIENT_REPOSITORY osmclient IM"
 174     sudo apt-get -y update
 175     sudo DEBIAN_FRONTEND=noninteractive apt-get install -y python3-pip
 176     sudo -H LC_ALL=C python3 -m pip install -U pip
 177     sudo DEBIAN_FRONTEND=noninteractive apt-get install -y python3-osm-im python3-osmclient
 178     if [ -f /usr/lib/python3/dist-packages/osm_im/requirements.txt ]; then
 179         python3 -m pip install -r /usr/lib/python3/dist-packages/osm_im/requirements.txt
 180     fi
 181     if [ -f /usr/lib/python3/dist-packages/osmclient/requirements.txt ]; then
 182         sudo DEBIAN_FRONTEND=noninteractive apt-get install -y libmagic1
 183         python3 -m pip install -r /usr/lib/python3/dist-packages/osmclient/requirements.txt
 184     fi
 185     echo -e "\nOSM client installed"
 186     echo -e "OSM client assumes that OSM host is running in localhost (127.0.0.1)."
 187     echo -e "In case you want to interact with a different OSM host, you will have to configure this env variable in your .bashrc file:"
 188     echo "     export OSM_HOSTNAME=nbi.${OSM_DEFAULT_IP}.nip.io"
 189     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 190     return 0
 191 }
 192
 193 function docker_login() {
 194     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 195     echo "Docker login"
 196     [ -z "${DEBUG_INSTALL}" ] || DEBUG "Docker registry user: ${DOCKER_REGISTRY_USER}"
 197     sg docker -c "docker login -u ${DOCKER_REGISTRY_USER} -p ${DOCKER_REGISTRY_PASSWORD} --password-stdin"
 198     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 199 }
 200
 201 #deploys osm pods and services
 202 function deploy_osm_helm_chart() {
 203     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 204     # Generate helm values to be passed with -f osm-values.yaml
 205     sudo mkdir -p ${OSM_HELM_WORK_DIR}
 206     if [ -n "${INSTALL_JUJU}" ]; then
 207         sudo bash -c "cat << EOF > ${OSM_HELM_WORK_DIR}/osm-values.yaml
 208 vca:
 209   pubkey: \"${OSM_VCA_PUBKEY}\"
 210 EOF"
 211     fi
 212
 213     # Generate helm values to be passed with --set
 214     OSM_HELM_OPTS=""
 215     # OSM_HELM_OPTS="${OSM_HELM_OPTS} --set nbi.useOsmSecret=false"
 216
 217     OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.image.repositoryBase=${DOCKER_REGISTRY_URL}${DOCKER_USER}"
 218     [ ! "$OSM_DOCKER_TAG" == "testing-daily" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set-string global.image.tag=${OSM_DOCKER_TAG}"
 219     [ ! "$OSM_DOCKER_TAG" == "testing-daily" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set prometheus.server.sidecarContainers.prometheus-config-sidecar.image=${DOCKER_REGISTRY_URL}${DOCKER_USER}/prometheus:${OSM_DOCKER_TAG}"
 220
 221     OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.hostname=${OSM_DEFAULT_IP}.nip.io"
 222     OSM_HELM_OPTS="${OSM_HELM_OPTS} --set grafana.ingress.hosts={grafana.${OSM_DEFAULT_IP}.nip.io}"
 223     OSM_HELM_OPTS="${OSM_HELM_OPTS} --set prometheus.server.ingress.hosts={prometheus.${OSM_DEFAULT_IP}.nip.io}"
 224     # OSM_HELM_OPTS="${OSM_HELM_OPTS} --set prometheus.alertmanager.ingress.hosts={alertmanager.${OSM_DEFAULT_IP}.nip.io}"
 225
 226     if [ -n "${INSTALL_JUJU}" ]; then
 227         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set vca.enabled=true"
 228         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set vca.host=${OSM_VCA_HOST}"
 229         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set vca.secret=${OSM_VCA_SECRET}"
 230         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set vca.cacert=${OSM_VCA_CACERT}"
 231     fi
 232     [ -n "$OSM_VCA_APIPROXY" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set lcm.config.OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}"
 233
 234     [ -n "${INSTALL_NGSA}" ] || OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.oldServiceAssurance=true"
 235     if [ -n "${OSM_BEHIND_PROXY}" ]; then
 236         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.behindHttpProxy=true"
 237         [ -n "${HTTP_PROXY}" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.HTTP_PROXY=\"${HTTP_PROXY}\""
 238         [ -n "${HTTPS_PROXY}" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.HTTPS_PROXY=\"${HTTPS_PROXY}\""
 239         if [ -n "${NO_PROXY}" ]; then
 240             if [[ ! "${NO_PROXY}" =~ .*".svc".* ]]; then
 241                 NO_PROXY="${NO_PROXY},.svc"
 242             fi
 243             if [[ ! "${NO_PROXY}" =~ .*".cluster.local".* ]]; then
 244                 NO_PROXY="${NO_PROXY},.cluster.local"
 245             fi
 246             OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.NO_PROXY=\"${NO_PROXY//,/\,}\""
 247         fi
 248     fi
 249
 250     if [ -n "${INSTALL_JUJU}" ]; then
 251         OSM_HELM_OPTS="-f ${OSM_HELM_WORK_DIR}/osm-values.yaml ${OSM_HELM_OPTS}"
 252     fi
 253     echo "helm upgrade --install -n $OSM_NAMESPACE --create-namespace $OSM_NAMESPACE $OSM_DEVOPS/installers/helm/osm ${OSM_HELM_OPTS}"
 254     helm upgrade --install -n $OSM_NAMESPACE --create-namespace $OSM_NAMESPACE $OSM_DEVOPS/installers/helm/osm ${OSM_HELM_OPTS}
 255     # Override existing values.yaml with the final values.yaml used to install OSM
 256     helm -n $OSM_NAMESPACE get values $OSM_NAMESPACE | sudo tee -a ${OSM_HELM_WORK_DIR}/osm-values.yaml
 257     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 258 }
 259
 260 #deploy charmed services
 261 function deploy_charmed_services() {
 262     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 263     juju add-model $OSM_NAMESPACE $OSM_VCA_K8S_CLOUDNAME
 264     juju deploy ch:mongodb-k8s -m $OSM_NAMESPACE --channel latest/stable
 265     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 266 }
 267
 268 #deploy mongodb
 269 function deploy_mongodb() {
 270     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 271     MONGO_OPTS="-d ${OSM_HELM_WORK_DIR} -D ${OSM_DEVOPS} -s ${OSM_NAMESPACE} -t ${OSM_DOCKER_TAG} -U ${DOCKER_USER} ${DEBUG_INSTALL}"
 272     [ -n "${DOCKER_REGISTRY_URL}" ] && MONGO_OPTS="${MONGO_OPTS} -r ${DOCKER_REGISTRY_URL}"
 273     $OSM_DEVOPS/installers/install_mongodb.sh ${MONGO_OPTS} || \
 274     FATAL_TRACK install_osm_mongodb_service "install_mongodb.sh failed"
 275     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 276 }
 277
 278 function install_osm_ngsa_service() {
 279     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 280     NGSA_OPTS="-i ${OSM_DEFAULT_IP} -d ${OSM_HELM_WORK_DIR} -D ${OSM_DEVOPS} -s ${OSM_NAMESPACE} -t ${OSM_DOCKER_TAG} -U ${DOCKER_USER} ${DEBUG_INSTALL}"
 281     [ -n "${DOCKER_REGISTRY_URL}" ] && NGSA_OPTS="${NGSA_OPTS} -r ${DOCKER_REGISTRY_URL}"
 282     $OSM_DEVOPS/installers/install_ngsa.sh ${NGSA_OPTS} || \
 283     FATAL_TRACK install_osm_ngsa_service "install_ngsa.sh failed"
 284     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 285 }
 286
 287 function add_local_k8scluster() {
 288     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 289     # OSM_HOSTNAME=$(kubectl get --namespace osm -o jsonpath="{.spec.rules[0].host}" ingress nbi-ingress)
 290     OSM_HOSTNAME="nbi.${OSM_DEFAULT_IP}.nip.io:443"
 291     /usr/bin/osm --hostname ${OSM_HOSTNAME} --all-projects vim-create \
 292       --name _system-osm-vim \
 293       --account_type dummy \
 294       --auth_url http://dummy \
 295       --user osm --password osm --tenant osm \
 296       --description "dummy" \
 297       --config '{management_network_name: mgmt}'
 298     /usr/bin/osm --hostname ${OSM_HOSTNAME} --all-projects k8scluster-add \
 299       --creds ${HOME}/.kube/config \
 300       --vim _system-osm-vim \
 301       --k8s-nets '{"net1": null}' \
 302       --version '1.29' \
 303       --description "OSM Internal Cluster" \
 304       _system-osm-k8s
 305     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 306 }
 307
 308 function configure_apt_proxy() {
 309     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 310     OSM_APT_PROXY=$1
 311     OSM_APT_PROXY_FILE="/etc/apt/apt.conf.d/osm-apt"
 312     echo "Configuring apt proxy in file ${OSM_APT_PROXY_FILE}"
 313     if [ ! -f ${OSM_APT_PROXY_FILE} ]; then
 314         sudo bash -c "cat <<EOF > ${OSM_APT_PROXY}
 315 Acquire::http { Proxy \"${OSM_APT_PROXY}\"; }
 316 EOF"
 317     else
 318         sudo sed -i "s|Proxy.*|Proxy \"${OSM_APT_PROXY}\"; }|" ${OSM_APT_PROXY_FILE}
 319     fi
 320     sudo apt-get update || FATAL "Configured apt proxy, but couldn't run 'apt-get update'. Check ${OSM_APT_PROXY_FILE}"
 321     track prereq apt_proxy_configured_ok
 322     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 323 }
 324
 325 function ask_proceed() {
 326     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 327
 328     [ -z "$ASSUME_YES" ] && ! ask_user "The installation will do the following
 329     1. Install and configure LXD
 330     2. Install juju
 331     3. Install docker CE
 332     4. Disable swap space
 333     5. Install and initialize Kubernetes
 334     as pre-requirements.
 335     Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1
 336
 337     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 338 }
 339
 340 function check_osm_behind_proxy() {
 341     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 342
 343     export OSM_BEHIND_PROXY=""
 344     export OSM_PROXY_ENV_VARIABLES=""
 345     [ -n "${http_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "http_proxy=${http_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} http_proxy"
 346     [ -n "${https_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${https_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} https_proxy"
 347     [ -n "${HTTP_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "HTTP_PROXY=${HTTP_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTP_PROXY"
 348     [ -n "${HTTPS_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${HTTPS_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTPS_PROXY"
 349     [ -n "${no_proxy}" ] && echo "no_proxy=${no_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} no_proxy"
 350     [ -n "${NO_PROXY}" ] && echo "NO_PROXY=${NO_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} NO_PROXY"
 351
 352     echo "OSM_BEHIND_PROXY=${OSM_BEHIND_PROXY}"
 353     echo "OSM_PROXY_ENV_VARIABLES=${OSM_PROXY_ENV_VARIABLES}"
 354
 355     if [ -n "${OSM_BEHIND_PROXY}" ]; then
 356         [ -z "$ASSUME_YES" ] && ! ask_user "
 357 The following env variables have been found for the current user:
 358 ${OSM_PROXY_ENV_VARIABLES}.
 359
 360 This suggests that this machine is behind a proxy and a special configuration is required.
 361 The installer will install Docker CE, LXD and Juju to work behind a proxy using those
 362 env variables.
 363
 364 Take into account that the installer uses apt, curl, wget, docker, lxd, juju and snap.
 365 Depending on the program, the env variables to work behind a proxy might be different
 366 (e.g. http_proxy vs HTTP_PROXY).
 367
 368 For that reason, it is strongly recommended that at least http_proxy, https_proxy, HTTP_PROXY
 369 and HTTPS_PROXY are defined.
 370
 371 Finally, some of the programs (apt, snap) those programs are run as sudoer, requiring that
 372 those env variables are also set for root user. If you are not sure whether those variables
 373 are configured for the root user, you can stop the installation now.
 374
 375 Do you want to proceed with the installation (Y/n)? " y && echo "Cancelled!" && exit 1
 376     else
 377         echo "This machine is not behind a proxy"
 378     fi
 379
 380     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 381 }
 382
 383 function find_devops_folder() {
 384     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 385     if [ -z "$OSM_DEVOPS" ]; then
 386         if [ -n "$TEST_INSTALLER" ]; then
 387             echo -e "\nUsing local devops repo for OSM installation"
 388             OSM_DEVOPS="$(dirname $(realpath $(dirname $0)))"
 389         else
 390             echo -e "\nCreating temporary dir for OSM installation"
 391             OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")"
 392             trap 'rm -rf "$OSM_DEVOPS"' EXIT
 393             git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS
 394         fi
 395     fi
 396     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 397 }
 398
 399 function install_lxd() {
 400     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 401     LXD_INSTALL_OPTS="-D ${OSM_DEVOPS} -i ${OSM_DEFAULT_IF} ${DEBUG_INSTALL}"
 402     [ -n "${OSM_BEHIND_PROXY}" ] && LXD_INSTALL_OPTS="${LXD_INSTALL_OPTS} -P"
 403     $OSM_DEVOPS/installers/install_lxd.sh ${LXD_INSTALL_OPTS} || FATAL_TRACK lxd "install_lxd.sh failed"
 404     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 405 }
 406
 407 function install_docker_ce() {
 408     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 409     DOCKER_CE_OPTS="-D ${OSM_DEVOPS} ${DEBUG_INSTALL}"
 410     [ -n "${DOCKER_PROXY_URL}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -p ${DOCKER_PROXY_URL}"
 411     [ -n "${OSM_BEHIND_PROXY}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -P"
 412     $OSM_DEVOPS/installers/install_docker_ce.sh ${DOCKER_CE_OPTS} || FATAL_TRACK docker_ce "install_docker_ce.sh failed"
 413     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 414 }
 415
 416 function install_k8s_cluster() {
 417     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 418     if [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then
 419         KUBEADM_INSTALL_OPTS="-d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL}"
 420         $OSM_DEVOPS/installers/install_kubeadm_cluster.sh ${KUBEADM_INSTALL_OPTS} || \
 421         FATAL_TRACK k8scluster "install_kubeadm_cluster.sh failed"
 422         K8SCLUSTER_ADDONS_INSTALL_OPTS="-i ${OSM_DEFAULT_IP} -d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL} --all"
 423         $OSM_DEVOPS/installers/install_cluster_addons.sh ${K8SCLUSTER_ADDONS_INSTALL_OPTS} || \
 424         FATAL_TRACK k8scluster "install_cluster_addons.sh failed for kubeadm cluster"
 425     elif [ "${K8S_CLUSTER_ENGINE}" == "k3s" ]; then
 426         K3S_INSTALL_OPTS="-i ${OSM_DEFAULT_IP} -D ${OSM_DEVOPS} ${DEBUG_INSTALL}"
 427         # The K3s installation script will automatically take the HTTP_PROXY, HTTPS_PROXY and NO_PROXY,
 428         # as well as the CONTAINERD_HTTP_PROXY, CONTAINERD_HTTPS_PROXY and CONTAINERD_NO_PROXY variables
 429         # from the shell, if they are present, and write them to the environment file of k3s systemd service,
 430         $OSM_DEVOPS/installers/install_k3s_cluster.sh ${K3S_INSTALL_OPTS} || \
 431         FATAL_TRACK k8scluster "install_k3s_cluster.sh failed"
 432         K8SCLUSTER_ADDONS_INSTALL_OPTS="-i ${OSM_DEFAULT_IP} -d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL} --certmgr --nginx"
 433         $OSM_DEVOPS/installers/install_cluster_addons.sh ${K8SCLUSTER_ADDONS_INSTALL_OPTS} || \
 434         FATAL_TRACK k8scluster "install_cluster_addons.sh failed for k3s cluster"
 435     fi
 436     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 437 }
 438
 439 function deploy_osm() {
 440     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 441     deploy_mongodb
 442     track deploy_osm deploy_mongodb_ok
 443     deploy_osm_helm_chart
 444     track deploy_osm deploy_osm_services_k8s_ok
 445     if [ -n "$INSTALL_NGSA" ]; then
 446         # optional NGSA install
 447         install_osm_ngsa_service
 448         track deploy_osm install_osm_ngsa_ok
 449     fi
 450     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 451 }
 452
 453 function install_osm() {
 454     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 455
 456     trap ctrl_c INT
 457
 458     check_osm_behind_proxy
 459     check_packages "git wget curl tar snapd"
 460     if [ -n "${INSTALL_JUJU}" ]; then
 461         sudo snap install jq || FATAL "Could not install jq (snap package). Make sure that snap works"
 462     fi
 463     find_devops_folder
 464
 465     track start release $RELEASE none none docker_tag $OSM_DOCKER_TAG none none installation_type $OSM_INSTALLATION_TYPE none none os_info $os_info none none
 466
 467     track checks checkingroot_ok
 468     [ "$USER" == "root" ] && FATAL "You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges."
 469     track checks noroot_ok
 470     ask_proceed
 471     track checks proceed_ok
 472
 473     echo "Installing OSM"
 474
 475     [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url
 476
 477     echo "Determining IP address of the interface with the default route"
 478     [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}')
 479     [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
 480     [ -z "$OSM_DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0"
 481     OSM_DEFAULT_IP=`ip -o -4 a s ${OSM_DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]; exit}'`
 482     [ -z "$OSM_DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route"
 483
 484     # configure apt proxy
 485     [ -n "$APT_PROXY_URL" ] && configure_apt_proxy $APT_PROXY_URL
 486
 487     # if lxd is requested, we will install it
 488     [ -n "$INSTALL_LXD" ] && install_lxd
 489
 490     track prereq prereqok_ok
 491
 492     if [ -n "$INSTALL_DOCKER" ] || [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then
 493         if [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then
 494             echo "Kubeadm requires docker, so docker will be installed."
 495         fi
 496         install_docker_ce
 497     fi
 498     track docker_ce docker_ce_ok
 499
 500     $OSM_DEVOPS/installers/install_helm_client.sh -D ${OSM_DEVOPS} ${DEBUG_INSTALL} || \
 501     FATAL_TRACK k8scluster "install_helm_client.sh failed"
 502     track helm_client install_helm_client_ok
 503
 504     install_k8s_cluster
 505     track k8scluster k8scluster_ok
 506
 507     if [ -n "${INSTALL_JUJU}" ]; then
 508         JUJU_OPTS="-D ${OSM_DEVOPS} -s ${OSM_NAMESPACE} -i ${OSM_DEFAULT_IP} ${DEBUG_INSTALL} ${INSTALL_CACHELXDIMAGES}"
 509         [ -n "${OSM_VCA_HOST}" ] && JUJU_OPTS="$JUJU_OPTS -H ${OSM_VCA_HOST}"
 510         [ -n "${LXD_CLOUD_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -l ${LXD_CLOUD_FILE}"
 511         [ -n "${LXD_CRED_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -L ${LXD_CRED_FILE}"
 512         [ -n "${CONTROLLER_NAME}" ] && JUJU_OPTS="$JUJU_OPTS -K ${CONTROLLER_NAME}"
 513         [ -n "${OSM_BEHIND_PROXY}" ] && JUJU_OPTS="${JUJU_OPTS} -P"
 514         $OSM_DEVOPS/installers/install_juju.sh ${JUJU_OPTS} || FATAL_TRACK juju "install_juju.sh failed"
 515         set_vca_variables
 516     fi
 517     track juju juju_ok
 518
 519     # This track is maintained for backwards compatibility
 520     track docker_images docker_images_ok
 521
 522     # Deploy OSM (mongodb, OSM helm chart, NGSA)
 523     deploy_osm
 524
 525     if [ -n "$INSTALL_K8S_MONITOR" ]; then
 526         # install OSM MONITORING
 527         install_k8s_monitoring
 528         track deploy_osm install_k8s_monitoring_ok
 529     fi
 530
 531     [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
 532     track osmclient osmclient_ok
 533
 534     echo -e "Checking OSM health state..."
 535     $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_NAMESPACE} -k || \
 536     (echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
 537     echo -e "Check OSM status with: kubectl -n ${OSM_NAMESPACE} get all" && \
 538     track healthchecks osm_unhealthy didnotconverge)
 539     track healthchecks after_healthcheck_ok
 540
 541     add_local_k8scluster
 542     track final_ops add_local_k8scluster_ok
 543
 544     # if lxd is requested, iptables firewall is updated to work with both docker and LXD
 545     if [ -n "$INSTALL_LXD" ]; then
 546         arrange_docker_default_network_policy
 547     fi
 548
 549     wget -q -O- https://osm-download.etsi.org/ftp/osm-15.0-fifteen/README2.txt &> /dev/null
 550     track end
 551     sudo find /etc/osm
 552     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 553     return 0
 554 }
 555
 556 function install_to_openstack() {
 557     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 558
 559     if [ -z "$2" ]; then
 560         FATAL "OpenStack installer requires a valid external network name"
 561     fi
 562
 563     # Install Pip for Python3
 564     sudo apt install -y python3-pip python3-venv
 565     sudo -H LC_ALL=C python3 -m pip install -U pip
 566
 567     # Create a venv to avoid conflicts with the host installation
 568     python3 -m venv $OPENSTACK_PYTHON_VENV
 569
 570     source $OPENSTACK_PYTHON_VENV/bin/activate
 571
 572     # Install Ansible, OpenStack client and SDK, latest openstack version supported is Train
 573     python -m pip install -U wheel
 574     python -m pip install -U "python-openstackclient<=4.0.2" "openstacksdk>=0.12.0,<=0.36.2" "ansible>=2.10,<2.11"
 575
 576     # Install the Openstack cloud module (ansible>=2.10)
 577     ansible-galaxy collection install openstack.cloud
 578
 579     export ANSIBLE_CONFIG="$OSM_DEVOPS/installers/openstack/ansible.cfg"
 580
 581     OSM_INSTALLER_ARGS="${REPO_ARGS[@]}"
 582
 583     ANSIBLE_VARS="external_network_name=$2 setup_volume=$3 server_name=$OPENSTACK_VM_NAME"
 584
 585     if [ -n "$OPENSTACK_SSH_KEY_FILE" ]; then
 586         ANSIBLE_VARS+=" key_file=$OPENSTACK_SSH_KEY_FILE"
 587     fi
 588
 589     if [ -n "$OPENSTACK_USERDATA_FILE" ]; then
 590         ANSIBLE_VARS+=" userdata_file=$OPENSTACK_USERDATA_FILE"
 591     fi
 592
 593     # Execute the Ansible playbook based on openrc or clouds.yaml
 594     if [ -e "$1" ]; then
 595         . $1
 596         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 597         $OSM_DEVOPS/installers/openstack/site.yml
 598     else
 599         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 600         -e cloud_name=$1 $OSM_DEVOPS/installers/openstack/site.yml
 601     fi
 602
 603     # Exit from venv
 604     deactivate
 605
 606     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 607     return 0
 608 }
 609
 610 function arrange_docker_default_network_policy() {
 611     echo -e "Fixing firewall so docker and LXD can share the same host without affecting each other."
 612     sudo iptables -I DOCKER-USER -j ACCEPT
 613     sudo iptables-save | sudo tee /etc/iptables/rules.v4
 614     sudo ip6tables-save | sudo tee /etc/iptables/rules.v6
 615 }
 616
 617 function install_k8s_monitoring() {
 618     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 619     # install OSM monitoring
 620     sudo $OSM_DEVOPS/installers/k8s/install_osm_k8s_monitoring.sh -o ${OSM_NAMESPACE} || FATAL_TRACK install_k8s_monitoring "k8s/install_osm_k8s_monitoring.sh failed"
 621     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 622 }
 623
 624 function dump_vars(){
 625     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 626     echo "APT_PROXY_URL=$APT_PROXY_URL"
 627     echo "K8S_CLUSTER_ENGINE=$K8S_CLUSTER_ENGINE"
 628     echo "DEBUG_INSTALL=$DEBUG_INSTALL"
 629     echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL"
 630     echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL"
 631     echo "DOCKER_USER=$DOCKER_USER"
 632     echo "INSTALL_CACHELXDIMAGES=$INSTALL_CACHELXDIMAGES"
 633     echo "INSTALL_JUJU=$INSTALL_JUJU"
 634     echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
 635     echo "INSTALL_LXD=$INSTALL_LXD"
 636     echo "INSTALL_NGSA=$INSTALL_NGSA"
 637     echo "INSTALL_DOCKER=$INSTALL_DOCKER"
 638     echo "INSTALL_ONLY=$INSTALL_ONLY"
 639     echo "INSTALL_ONLY_DEPLOY_OSM=$INSTALL_ONLY_DEPLOY_OSM"
 640     echo "INSTALL_ONLY_DOCKER_CE=$INSTALL_ONLY_DOCKER_CE"
 641     echo "INSTALL_ONLY_K8S_CLUSTER=$INSTALL_ONLY_K8S_CLUSTER"
 642     echo "INSTALL_ONLY_NGSA=$INSTALL_ONLY_NGSA"
 643     echo "INSTALL_PLA=$INSTALL_PLA"
 644     echo "INSTALL_TO_OPENSTACK=$INSTALL_TO_OPENSTACK"
 645     echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
 646     echo "NO_HOST_PORTS=$NO_HOST_PORTS"
 647     echo "OPENSTACK_PUBLIC_NET_NAME=$OPENSTACK_PUBLIC_NET_NAME"
 648     echo "OPENSTACK_OPENRC_FILE_OR_CLOUD=$OPENSTACK_OPENRC_FILE_OR_CLOUD"
 649     echo "OPENSTACK_ATTACH_VOLUME=$OPENSTACK_ATTACH_VOLUME"
 650     echo "OPENSTACK_SSH_KEY_FILE"="$OPENSTACK_SSH_KEY_FILE"
 651     echo "OPENSTACK_USERDATA_FILE"="$OPENSTACK_USERDATA_FILE"
 652     echo "OPENSTACK_VM_NAME"="$OPENSTACK_VM_NAME"
 653     echo "OSM_DEVOPS=$OSM_DEVOPS"
 654     echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
 655     echo "OSM_HELM_WORK_DIR=$OSM_HELM_WORK_DIR"
 656     echo "OSM_NAMESPACE=$OSM_NAMESPACE"
 657     echo "OSM_VCA_HOST=$OSM_VCA_HOST"
 658     echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
 659     echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
 660     echo "OSM_WORK_DIR=$OSM_WORK_DIR"
 661     echo "PULL_IMAGES=$PULL_IMAGES"
 662     echo "RECONFIGURE=$RECONFIGURE"
 663     echo "RELEASE=$RELEASE"
 664     echo "REPOSITORY=$REPOSITORY"
 665     echo "REPOSITORY_BASE=$REPOSITORY_BASE"
 666     echo "REPOSITORY_KEY=$REPOSITORY_KEY"
 667     echo "SHOWOPTS=$SHOWOPTS"
 668     echo "TEST_INSTALLER=$TEST_INSTALLER"
 669     echo "UNINSTALL=$UNINSTALL"
 670     echo "UPDATE=$UPDATE"
 671     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 672 }
 673
 674 function parse_docker_registry_url() {
 675     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 676     DOCKER_REGISTRY_USER=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}')
 677     DOCKER_REGISTRY_PASSWORD=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}')
 678     DOCKER_REGISTRY_URL=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); print a[2]}')
 679     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 680 }
 681
 682 function ctrl_c() {
 683     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 684     echo "** Trapped CTRL-C"
 685     FATAL "User stopped the installation"
 686     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 687 }
 688
 689 UNINSTALL=""
 690 UPDATE=""
 691 RECONFIGURE=""
 692 TEST_INSTALLER=""
 693 INSTALL_LXD=""
 694 SHOWOPTS=""
 695 ASSUME_YES=""
 696 APT_PROXY_URL=""
 697 K8S_CLUSTER_ENGINE="k3s"
 698 DEBUG_INSTALL=""
 699 RELEASE="testing-daily"
 700 REPOSITORY="testing"
 701 INSTALL_K8S_MONITOR=""
 702 INSTALL_NGSA="y"
 703 INSTALL_PLA=""
 704 INSTALL_VIMEMU=""
 705 LXD_REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/lxd"
 706 LXD_REPOSITORY_PATH=""
 707 INSTALL_TO_OPENSTACK=""
 708 OPENSTACK_OPENRC_FILE_OR_CLOUD=""
 709 OPENSTACK_PUBLIC_NET_NAME=""
 710 OPENSTACK_ATTACH_VOLUME="false"
 711 OPENSTACK_SSH_KEY_FILE=""
 712 OPENSTACK_USERDATA_FILE=""
 713 OPENSTACK_VM_NAME="server-osm"
 714 OPENSTACK_PYTHON_VENV="$HOME/.virtual-envs/osm"
 715 INSTALL_ONLY=""
 716 INSTALL_ONLY_DEPLOY_OSM=""
 717 INSTALL_ONLY_DOCKER_CE=""
 718 INSTALL_ONLY_K8S_CLUSTER=""
 719 INSTALL_ONLY_NGSA=""
 720 INSTALL_DOCKER=""
 721 INSTALL_JUJU=""
 722 INSTALL_NOHOSTCLIENT=""
 723 INSTALL_CACHELXDIMAGES=""
 724 OSM_DEVOPS=
 725 OSM_VCA_HOST=
 726 OSM_VCA_SECRET=
 727 OSM_VCA_PUBKEY=
 728 OSM_VCA_CLOUDNAME="localhost"
 729 OSM_VCA_K8S_CLOUDNAME="k8scloud"
 730 OSM_NAMESPACE=osm
 731 NO_HOST_PORTS=""
 732 REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
 733 REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian"
 734 OSM_WORK_DIR="/etc/osm"
 735 OSM_HELM_WORK_DIR="${OSM_WORK_DIR}/helm"
 736 OSM_HOST_VOL="/var/lib/osm"
 737 OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_NAMESPACE}"
 738 OSM_DOCKER_TAG="testing-daily"
 739 DOCKER_USER=opensourcemano
 740 PULL_IMAGES="y"
 741 KAFKA_TAG=2.11-1.0.2
 742 KIWIGRID_K8S_SIDECAR_TAG="1.15.6"
 743 PROMETHEUS_TAG=v2.28.1
 744 GRAFANA_TAG=8.1.1
 745 PROMETHEUS_NODE_EXPORTER_TAG=0.18.1
 746 PROMETHEUS_CADVISOR_TAG=latest
 747 KEYSTONEDB_TAG=10
 748 OSM_DATABASE_COMMONKEY=
 749 ELASTIC_VERSION=6.4.2
 750 ELASTIC_CURATOR_VERSION=5.5.4
 751 POD_NETWORK_CIDR=10.244.0.0/16
 752 K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
 753 RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
 754 DOCKER_REGISTRY_URL=
 755 DOCKER_PROXY_URL=
 756 MODULE_DOCKER_TAG=
 757 OSM_INSTALLATION_TYPE="Default"
 758
 759 while getopts ":a:c:r:n:k:u:R:D:o:O:N:H:S:s:t:U:P:A:l:L:K:d:p:T:f:F:-: hy" o; do
 760     case "${o}" in
 761         a)
 762             APT_PROXY_URL=${OPTARG}
 763             ;;
 764         c)
 765             K8S_CLUSTER_ENGINE=${OPTARG}
 766             [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ] && continue
 767             [ "${K8S_CLUSTER_ENGINE}" == "k3s" ] && continue
 768             echo -e "Invalid argument for -c : ' ${K8S_CLUSTER_ENGINE}'\n" >&2
 769             usage && exit 1
 770             ;;
 771         r)
 772             REPOSITORY="${OPTARG}"
 773             REPO_ARGS+=(-r "$REPOSITORY")
 774             ;;
 775         k)
 776             REPOSITORY_KEY="${OPTARG}"
 777             REPO_ARGS+=(-k "$REPOSITORY_KEY")
 778             ;;
 779         u)
 780             REPOSITORY_BASE="${OPTARG}"
 781             REPO_ARGS+=(-u "$REPOSITORY_BASE")
 782             ;;
 783         R)
 784             RELEASE="${OPTARG}"
 785             REPO_ARGS+=(-R "$RELEASE")
 786             ;;
 787         D)
 788             OSM_DEVOPS="${OPTARG}"
 789             ;;
 790         o)
 791             INSTALL_ONLY="y"
 792             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
 793             [ "${OPTARG}" == "ng-sa" ] && INSTALL_ONLY_NGSA="y" && continue
 794             [ "${OPTARG}" == "docker" ] && INSTALL_ONLY_DOCKER_CE="y" && continue
 795             [ "${OPTARG}" == "k8scluster" ] && INSTALL_ONLY_K8S_CLUSTER="y" && continue
 796             [ "${OPTARG}" == "deploy-osm" ] && INSTALL_ONLY_DEPLOY_OSM="y" && continue
 797             ;;
 798         O)
 799             INSTALL_TO_OPENSTACK="y"
 800             if [ -n "${OPTARG}" ]; then
 801                 OPENSTACK_OPENRC_FILE_OR_CLOUD="${OPTARG}"
 802             else
 803                 echo -e "Invalid argument for -O : ' $OPTARG'\n" >&2
 804                 usage && exit 1
 805             fi
 806             ;;
 807         f)
 808             OPENSTACK_SSH_KEY_FILE="${OPTARG}"
 809             ;;
 810         F)
 811             OPENSTACK_USERDATA_FILE="${OPTARG}"
 812             ;;
 813         N)
 814             OPENSTACK_PUBLIC_NET_NAME="${OPTARG}"
 815             ;;
 816         H)
 817             OSM_VCA_HOST="${OPTARG}"
 818             ;;
 819         S)
 820             OSM_VCA_SECRET="${OPTARG}"
 821             ;;
 822         s)
 823             OSM_NAMESPACE="${OPTARG}" && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
 824             ;;
 825         t)
 826             OSM_DOCKER_TAG="${OPTARG}"
 827             REPO_ARGS+=(-t "$OSM_DOCKER_TAG")
 828             ;;
 829         U)
 830             DOCKER_USER="${OPTARG}"
 831             ;;
 832         P)
 833             OSM_VCA_PUBKEY=$(cat ${OPTARG})
 834             ;;
 835         A)
 836             OSM_VCA_APIPROXY="${OPTARG}"
 837             ;;
 838         l)
 839             LXD_CLOUD_FILE="${OPTARG}"
 840             ;;
 841         L)
 842             LXD_CRED_FILE="${OPTARG}"
 843             ;;
 844         K)
 845             CONTROLLER_NAME="${OPTARG}"
 846             ;;
 847         d)
 848             DOCKER_REGISTRY_URL="${OPTARG}"
 849             ;;
 850         p)
 851             DOCKER_PROXY_URL="${OPTARG}"
 852             ;;
 853         T)
 854             MODULE_DOCKER_TAG="${OPTARG}"
 855             ;;
 856         -)
 857             [ "${OPTARG}" == "help" ] && usage && exit 0
 858             [ "${OPTARG}" == "debug" ] && DEBUG_INSTALL="--debug" && continue
 859             [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue
 860             [ "${OPTARG}" == "update" ] && UPDATE="y" && continue
 861             [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE="y" && continue
 862             [ "${OPTARG}" == "test" ] && TEST_INSTALLER="y" && continue
 863             [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD="y" && continue
 864             [ "${OPTARG}" == "lxd" ] && INSTALL_LXD="y" && continue
 865             [ "${OPTARG}" == "nolxd" ] && INSTALL_LXD="" && continue
 866             [ "${OPTARG}" == "docker" ] && INSTALL_DOCKER="y" && continue
 867             [ "${OPTARG}" == "nodocker" ] && INSTALL_DOCKER="" && continue
 868             [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue
 869             [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS="y" && continue
 870             [ "${OPTARG}" == "juju" ] && INSTALL_JUJU="y" && continue
 871             [ "${OPTARG}" == "nojuju" ] && INSTALL_JUJU="" && continue
 872             [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue
 873             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
 874             [ "${OPTARG}" == "charmed" ] && CHARMED="y" && OSM_INSTALLATION_TYPE="Charmed" && continue
 875             [ "${OPTARG}" == "bundle" ] && continue
 876             [ "${OPTARG}" == "k8s" ] && continue
 877             [ "${OPTARG}" == "lxd-cred" ] && continue
 878             [ "${OPTARG}" == "microstack" ] && continue
 879             [ "${OPTARG}" == "overlay" ] && continue
 880             [ "${OPTARG}" == "only-vca" ] && continue
 881             [ "${OPTARG}" == "small-profile" ] && continue
 882             [ "${OPTARG}" == "vca" ] && continue
 883             [ "${OPTARG}" == "ha" ] && continue
 884             [ "${OPTARG}" == "tag" ] && continue
 885             [ "${OPTARG}" == "registry" ] && continue
 886             [ "${OPTARG}" == "pla" ] && INSTALL_PLA="y" && continue
 887             [ "${OPTARG}" == "old-sa" ] && INSTALL_NGSA="" && continue
 888             [ "${OPTARG}" == "ng-sa" ] && INSTALL_NGSA="y" && continue
 889             [ "${OPTARG}" == "volume" ] && OPENSTACK_ATTACH_VOLUME="true" && continue
 890             [ "${OPTARG}" == "nocachelxdimages" ] && continue
 891             [ "${OPTARG}" == "cachelxdimages" ] && INSTALL_CACHELXDIMAGES="--cachelxdimages" && continue
 892             echo -e "Invalid option: '--$OPTARG'\n" >&2
 893             usage && exit 1
 894             ;;
 895         :)
 896             echo "Option -$OPTARG requires an argument" >&2
 897             usage && exit 1
 898             ;;
 899         \?)
 900             echo -e "Invalid option: '-$OPTARG'\n" >&2
 901             usage && exit 1
 902             ;;
 903         h)
 904             usage && exit 0
 905             ;;
 906         y)
 907             ASSUME_YES="y"
 908             ;;
 909         *)
 910             usage && exit 1
 911             ;;
 912     esac
 913 done
 914
 915 source $OSM_DEVOPS/common/all_funcs
 916
 917 [ -z "${DEBUG_INSTALL}" ] || DEBUG Debug is on
 918 [ -n "$SHOWOPTS" ] && dump_vars && exit 0
 919
 920 # Uninstall if "--uninstall"
 921 if [ -n "$UNINSTALL" ]; then
 922     if [ -n "$CHARMED" ]; then
 923         ${OSM_DEVOPS}/installers/charmed_uninstall.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D $OSM_DEVOPS -t $DOCKER_TAG "$@" || \
 924         FATAL_TRACK charmed_uninstall "charmed_uninstall.sh failed"
 925     else
 926         ${OSM_DEVOPS}/installers/uninstall_osm.sh "$@" || \
 927         FATAL_TRACK community_uninstall "uninstall_osm.sh failed"
 928     fi
 929     echo -e "\nDONE"
 930     exit 0
 931 fi
 932
 933 # Installation starts here
 934
 935 # Get README and create OSM_TRACK_INSTALLATION_ID
 936 wget -q -O- https://osm-download.etsi.org/ftp/osm-15.0-fifteen/README.txt &> /dev/null
 937 export OSM_TRACK_INSTALLATION_ID="$(date +%s)-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 16)"
 938
 939 # Get OS info to be tracked
 940 os_distro=$(lsb_release -i 2>/dev/null | awk '{print $3}')
 941 echo $os_distro
 942 os_release=$(lsb_release -r 2>/dev/null | awk '{print $2}')
 943 echo $os_release
 944 os_info="${os_distro}_${os_release}"
 945 os_info="${os_info// /_}"
 946
 947 if [ -n "$CHARMED" ]; then
 948     # Charmed installation
 949     sudo snap install jq || FATAL "Could not install jq (snap package). Make sure that snap works"
 950     ${OSM_DEVOPS}/installers/charmed_install.sh --tag $OSM_DOCKER_TAG "$@" || \
 951     FATAL_TRACK charmed_install "charmed_install.sh failed"
 952     wget -q -O- https://osm-download.etsi.org/ftp/osm-15.0-fifteen/README2.txt &> /dev/null
 953     echo -e "\nDONE"
 954     exit 0
 955 elif [ -n "$INSTALL_TO_OPENSTACK" ]; then
 956     # Installation to Openstack
 957     install_to_openstack $OPENSTACK_OPENRC_FILE_OR_CLOUD $OPENSTACK_PUBLIC_NET_NAME $OPENSTACK_ATTACH_VOLUME
 958     echo -e "\nDONE"
 959     exit 0
 960 else
 961     # Community_installer
 962     # Special cases go first
 963     if [ -n "$INSTALL_ONLY" ]; then
 964         [ -n "$INSTALL_ONLY_DOCKER_CE" ] && install_docker_ce
 965         [ -n "$INSTALL_ONLY_K8S_CLUSTER" ] && install_k8s_cluster
 966         [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
 967         [ -n "$INSTALL_ONLY_DEPLOY_OSM" ] && deploy_osm
 968         [ -n "$INSTALL_ONLY_NGSA" ] && install_osm_ngsa_service
 969         echo -e "\nDONE" && exit 0
 970     fi
 971     # This is where installation starts
 972     install_osm
 973     echo -e "\nDONE"
 974     exit 0
 975 fi