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     # OSM_HELM_OPTS="${OSM_HELM_OPTS} --set mysql.dbHostPath=${OSM_NAMESPACE_VOL}" # not needed as mysql is now bitnami helm chart
 217
 218     OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.image.repositoryBase=${DOCKER_REGISTRY_URL}${DOCKER_USER}"
 219     [ ! "$OSM_DOCKER_TAG" == "testing-daily" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set-string global.image.tag=${OSM_DOCKER_TAG}"
 220     [ ! "$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}"
 221
 222     OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.hostname=${OSM_DEFAULT_IP}.nip.io"
 223     OSM_HELM_OPTS="${OSM_HELM_OPTS} --set grafana.ingress.hosts={grafana.${OSM_DEFAULT_IP}.nip.io}"
 224     OSM_HELM_OPTS="${OSM_HELM_OPTS} --set prometheus.server.ingress.hosts={prometheus.${OSM_DEFAULT_IP}.nip.io}"
 225     # OSM_HELM_OPTS="${OSM_HELM_OPTS} --set prometheus.alertmanager.ingress.hosts={alertmanager.${OSM_DEFAULT_IP}.nip.io}"
 226
 227     if [ -n "${INSTALL_JUJU}" ]; then
 228         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set vca.enabled=true"
 229         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set vca.host=${OSM_VCA_HOST}"
 230         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set vca.secret=${OSM_VCA_SECRET}"
 231         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set vca.cacert=${OSM_VCA_CACERT}"
 232     fi
 233     [ -n "$OSM_VCA_APIPROXY" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set lcm.config.OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}"
 234
 235     [ -n "${INSTALL_NGSA}" ] || OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.oldServiceAssurance=true"
 236     if [ -n "${OSM_BEHIND_PROXY}" ]; then
 237         OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.behindHttpProxy=true"
 238         [ -n "${HTTP_PROXY}" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.HTTP_PROXY=\"${HTTP_PROXY}\""
 239         [ -n "${HTTPS_PROXY}" ] && OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.HTTPS_PROXY=\"${HTTPS_PROXY}\""
 240         if [ -n "${NO_PROXY}" ]; then
 241             if [[ ! "${NO_PROXY}" =~ .*".svc".* ]]; then
 242                 NO_PROXY="${NO_PROXY},.svc"
 243             fi
 244             if [[ ! "${NO_PROXY}" =~ .*".cluster.local".* ]]; then
 245                 NO_PROXY="${NO_PROXY},.cluster.local"
 246             fi
 247             OSM_HELM_OPTS="${OSM_HELM_OPTS} --set global.httpProxy.NO_PROXY=\"${NO_PROXY//,/\,}\""
 248         fi
 249     fi
 250
 251     if [ -n "${INSTALL_JUJU}" ]; then
 252         OSM_HELM_OPTS="-f ${OSM_HELM_WORK_DIR}/osm-values.yaml ${OSM_HELM_OPTS}"
 253     fi
 254     echo "helm upgrade --install -n $OSM_NAMESPACE --create-namespace $OSM_NAMESPACE $OSM_DEVOPS/installers/helm/osm ${OSM_HELM_OPTS}"
 255     helm upgrade --install -n $OSM_NAMESPACE --create-namespace $OSM_NAMESPACE $OSM_DEVOPS/installers/helm/osm ${OSM_HELM_OPTS}
 256     # Override existing values.yaml with the final values.yaml used to install OSM
 257     helm -n $OSM_NAMESPACE get values $OSM_NAMESPACE | sudo tee -a ${OSM_HELM_WORK_DIR}/osm-values.yaml
 258     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 259 }
 260
 261 #deploy charmed services
 262 function deploy_charmed_services() {
 263     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 264     juju add-model $OSM_NAMESPACE $OSM_VCA_K8S_CLOUDNAME
 265     juju deploy ch:mongodb-k8s -m $OSM_NAMESPACE --channel latest/stable
 266     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 267 }
 268
 269 #deploy mongodb
 270 function deploy_mongodb() {
 271     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 272     MONGO_OPTS="-d ${OSM_HELM_WORK_DIR} -D ${OSM_DEVOPS} -s ${OSM_NAMESPACE} -t ${OSM_DOCKER_TAG} -U ${DOCKER_USER} ${DEBUG_INSTALL}"
 273     [ -n "${DOCKER_REGISTRY_URL}" ] && MONGO_OPTS="${MONGO_OPTS} -r ${DOCKER_REGISTRY_URL}"
 274     $OSM_DEVOPS/installers/install_mongodb.sh ${MONGO_OPTS} || \
 275     FATAL_TRACK install_osm_mongodb_service "install_mongodb.sh failed"
 276     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 277 }
 278
 279 function install_osm_ngsa_service() {
 280     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 281     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}"
 282     [ -n "${DOCKER_REGISTRY_URL}" ] && NGSA_OPTS="${NGSA_OPTS} -r ${DOCKER_REGISTRY_URL}"
 283     $OSM_DEVOPS/installers/install_ngsa.sh ${NGSA_OPTS} || \
 284     FATAL_TRACK install_osm_ngsa_service "install_ngsa.sh failed"
 285     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 286 }
 287
 288 function add_local_k8scluster() {
 289     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 290     # OSM_HOSTNAME=$(kubectl get --namespace osm -o jsonpath="{.spec.rules[0].host}" ingress nbi-ingress)
 291     OSM_HOSTNAME="nbi.${OSM_DEFAULT_IP}.nip.io:443"
 292     /usr/bin/osm --hostname ${OSM_HOSTNAME} --all-projects vim-create \
 293       --name _system-osm-vim \
 294       --account_type dummy \
 295       --auth_url http://dummy \
 296       --user osm --password osm --tenant osm \
 297       --description "dummy" \
 298       --config '{management_network_name: mgmt}'
 299     /usr/bin/osm --hostname ${OSM_HOSTNAME} --all-projects k8scluster-add \
 300       --creds ${HOME}/.kube/config \
 301       --vim _system-osm-vim \
 302       --k8s-nets '{"net1": null}' \
 303       --version '1.29' \
 304       --description "OSM Internal Cluster" \
 305       _system-osm-k8s
 306     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 307 }
 308
 309 function configure_apt_proxy() {
 310     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 311     OSM_APT_PROXY=$1
 312     OSM_APT_PROXY_FILE="/etc/apt/apt.conf.d/osm-apt"
 313     echo "Configuring apt proxy in file ${OSM_APT_PROXY_FILE}"
 314     if [ ! -f ${OSM_APT_PROXY_FILE} ]; then
 315         sudo bash -c "cat <<EOF > ${OSM_APT_PROXY}
 316 Acquire::http { Proxy \"${OSM_APT_PROXY}\"; }
 317 EOF"
 318     else
 319         sudo sed -i "s|Proxy.*|Proxy \"${OSM_APT_PROXY}\"; }|" ${OSM_APT_PROXY_FILE}
 320     fi
 321     sudo apt-get update || FATAL "Configured apt proxy, but couldn't run 'apt-get update'. Check ${OSM_APT_PROXY_FILE}"
 322     track prereq apt_proxy_configured_ok
 323     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 324 }
 325
 326 function ask_proceed() {
 327     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 328
 329     [ -z "$ASSUME_YES" ] && ! ask_user "The installation will do the following
 330     1. Install and configure LXD
 331     2. Install juju
 332     3. Install docker CE
 333     4. Disable swap space
 334     5. Install and initialize Kubernetes
 335     as pre-requirements.
 336     Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1
 337
 338     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 339 }
 340
 341 function check_osm_behind_proxy() {
 342     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 343
 344     export OSM_BEHIND_PROXY=""
 345     export OSM_PROXY_ENV_VARIABLES=""
 346     [ -n "${http_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "http_proxy=${http_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} http_proxy"
 347     [ -n "${https_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${https_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} https_proxy"
 348     [ -n "${HTTP_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "HTTP_PROXY=${HTTP_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTP_PROXY"
 349     [ -n "${HTTPS_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${HTTPS_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTPS_PROXY"
 350     [ -n "${no_proxy}" ] && echo "no_proxy=${no_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} no_proxy"
 351     [ -n "${NO_PROXY}" ] && echo "NO_PROXY=${NO_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} NO_PROXY"
 352
 353     echo "OSM_BEHIND_PROXY=${OSM_BEHIND_PROXY}"
 354     echo "OSM_PROXY_ENV_VARIABLES=${OSM_PROXY_ENV_VARIABLES}"
 355
 356     if [ -n "${OSM_BEHIND_PROXY}" ]; then
 357         [ -z "$ASSUME_YES" ] && ! ask_user "
 358 The following env variables have been found for the current user:
 359 ${OSM_PROXY_ENV_VARIABLES}.
 360
 361 This suggests that this machine is behind a proxy and a special configuration is required.
 362 The installer will install Docker CE, LXD and Juju to work behind a proxy using those
 363 env variables.
 364
 365 Take into account that the installer uses apt, curl, wget, docker, lxd, juju and snap.
 366 Depending on the program, the env variables to work behind a proxy might be different
 367 (e.g. http_proxy vs HTTP_PROXY).
 368
 369 For that reason, it is strongly recommended that at least http_proxy, https_proxy, HTTP_PROXY
 370 and HTTPS_PROXY are defined.
 371
 372 Finally, some of the programs (apt, snap) those programs are run as sudoer, requiring that
 373 those env variables are also set for root user. If you are not sure whether those variables
 374 are configured for the root user, you can stop the installation now.
 375
 376 Do you want to proceed with the installation (Y/n)? " y && echo "Cancelled!" && exit 1
 377     else
 378         echo "This machine is not behind a proxy"
 379     fi
 380
 381     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 382 }
 383
 384 function find_devops_folder() {
 385     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 386     if [ -z "$OSM_DEVOPS" ]; then
 387         if [ -n "$TEST_INSTALLER" ]; then
 388             echo -e "\nUsing local devops repo for OSM installation"
 389             OSM_DEVOPS="$(dirname $(realpath $(dirname $0)))"
 390         else
 391             echo -e "\nCreating temporary dir for OSM installation"
 392             OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")"
 393             trap 'rm -rf "$OSM_DEVOPS"' EXIT
 394             git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS
 395         fi
 396     fi
 397     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 398 }
 399
 400 function install_lxd() {
 401     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 402     LXD_INSTALL_OPTS="-D ${OSM_DEVOPS} -i ${OSM_DEFAULT_IF} ${DEBUG_INSTALL}"
 403     [ -n "${OSM_BEHIND_PROXY}" ] && LXD_INSTALL_OPTS="${LXD_INSTALL_OPTS} -P"
 404     $OSM_DEVOPS/installers/install_lxd.sh ${LXD_INSTALL_OPTS} || FATAL_TRACK lxd "install_lxd.sh failed"
 405     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 406 }
 407
 408 function install_docker_ce() {
 409     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 410     DOCKER_CE_OPTS="-D ${OSM_DEVOPS} ${DEBUG_INSTALL}"
 411     [ -n "${DOCKER_PROXY_URL}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -p ${DOCKER_PROXY_URL}"
 412     [ -n "${OSM_BEHIND_PROXY}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -P"
 413     $OSM_DEVOPS/installers/install_docker_ce.sh ${DOCKER_CE_OPTS} || FATAL_TRACK docker_ce "install_docker_ce.sh failed"
 414     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 415 }
 416
 417 function install_k8s_cluster() {
 418     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 419     if [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then
 420         KUBEADM_INSTALL_OPTS="-d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL}"
 421         $OSM_DEVOPS/installers/install_kubeadm_cluster.sh ${KUBEADM_INSTALL_OPTS} || \
 422         FATAL_TRACK k8scluster "install_kubeadm_cluster.sh failed"
 423         K8SCLUSTER_ADDONS_INSTALL_OPTS="-i ${OSM_DEFAULT_IP} -d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL} --all"
 424         $OSM_DEVOPS/installers/install_cluster_addons.sh ${K8SCLUSTER_ADDONS_INSTALL_OPTS} || \
 425         FATAL_TRACK k8scluster "install_cluster_addons.sh failed for kubeadm cluster"
 426     elif [ "${K8S_CLUSTER_ENGINE}" == "k3s" ]; then
 427         K3S_INSTALL_OPTS="-D ${OSM_DEVOPS} ${DEBUG_INSTALL}"
 428         # The K3s installation script will automatically take the HTTP_PROXY, HTTPS_PROXY and NO_PROXY,
 429         # as well as the CONTAINERD_HTTP_PROXY, CONTAINERD_HTTPS_PROXY and CONTAINERD_NO_PROXY variables
 430         # from the shell, if they are present, and write them to the environment file of k3s systemd service,
 431         $OSM_DEVOPS/installers/install_k3s_cluster.sh ${K3S_INSTALL_OPTS} || \
 432         FATAL_TRACK k8scluster "install_k3s_cluster.sh failed"
 433         K8SCLUSTER_ADDONS_INSTALL_OPTS="-i ${OSM_DEFAULT_IP} -d ${OSM_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL} --certmgr --nginx"
 434         $OSM_DEVOPS/installers/install_cluster_addons.sh ${K8SCLUSTER_ADDONS_INSTALL_OPTS} || \
 435         FATAL_TRACK k8scluster "install_cluster_addons.sh failed for k3s cluster"
 436     fi
 437     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 438 }
 439
 440 function deploy_osm() {
 441     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 442     deploy_mongodb
 443     track deploy_osm deploy_mongodb_ok
 444     deploy_osm_helm_chart
 445     track deploy_osm deploy_osm_services_k8s_ok
 446     if [ -n "$INSTALL_NGSA" ]; then
 447         # optional NGSA install
 448         install_osm_ngsa_service
 449         track deploy_osm install_osm_ngsa_ok
 450     fi
 451     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 452 }
 453
 454 function install_osm() {
 455     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 456
 457     trap ctrl_c INT
 458
 459     check_osm_behind_proxy
 460     check_packages "git wget curl tar snapd"
 461     if [ -n "${INSTALL_JUJU}" ]; then
 462         sudo snap install jq || FATAL "Could not install jq (snap package). Make sure that snap works"
 463     fi
 464     find_devops_folder
 465
 466     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
 467
 468     track checks checkingroot_ok
 469     [ "$USER" == "root" ] && FATAL "You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges."
 470     track checks noroot_ok
 471     ask_proceed
 472     track checks proceed_ok
 473
 474     echo "Installing OSM"
 475
 476     [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url
 477
 478     echo "Determining IP address of the interface with the default route"
 479     [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}')
 480     [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
 481     [ -z "$OSM_DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0"
 482     OSM_DEFAULT_IP=`ip -o -4 a s ${OSM_DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]; exit}'`
 483     [ -z "$OSM_DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route"
 484
 485     # configure apt proxy
 486     [ -n "$APT_PROXY_URL" ] && configure_apt_proxy $APT_PROXY_URL
 487
 488     # if lxd is requested, we will install it
 489     [ -n "$INSTALL_LXD" ] && install_lxd
 490
 491     track prereq prereqok_ok
 492
 493     if [ -n "$INSTALL_DOCKER" ] || [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then
 494         if [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ]; then
 495             echo "Kubeadm requires docker, so docker will be installed."
 496         fi
 497         install_docker_ce
 498     fi
 499     track docker_ce docker_ce_ok
 500
 501     $OSM_DEVOPS/installers/install_helm_client.sh -D ${OSM_DEVOPS} ${DEBUG_INSTALL} || \
 502     FATAL_TRACK k8scluster "install_helm_client.sh failed"
 503     track helm_client install_helm_client_ok
 504
 505     install_k8s_cluster
 506     track k8scluster k8scluster_ok
 507
 508     if [ -n "${INSTALL_JUJU}" ]; then
 509         JUJU_OPTS="-D ${OSM_DEVOPS} -s ${OSM_NAMESPACE} -i ${OSM_DEFAULT_IP} ${DEBUG_INSTALL} ${INSTALL_CACHELXDIMAGES}"
 510         [ -n "${OSM_VCA_HOST}" ] && JUJU_OPTS="$JUJU_OPTS -H ${OSM_VCA_HOST}"
 511         [ -n "${LXD_CLOUD_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -l ${LXD_CLOUD_FILE}"
 512         [ -n "${LXD_CRED_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -L ${LXD_CRED_FILE}"
 513         [ -n "${CONTROLLER_NAME}" ] && JUJU_OPTS="$JUJU_OPTS -K ${CONTROLLER_NAME}"
 514         [ -n "${OSM_BEHIND_PROXY}" ] && JUJU_OPTS="${JUJU_OPTS} -P"
 515         $OSM_DEVOPS/installers/install_juju.sh ${JUJU_OPTS} || FATAL_TRACK juju "install_juju.sh failed"
 516         set_vca_variables
 517     fi
 518     track juju juju_ok
 519
 520     # This track is maintained for backwards compatibility
 521     track docker_images docker_images_ok
 522
 523     # Deploy OSM (mongodb, OSM helm chart, NGSA)
 524     deploy_osm
 525
 526     if [ -n "$INSTALL_K8S_MONITOR" ]; then
 527         # install OSM MONITORING
 528         install_k8s_monitoring
 529         track deploy_osm install_k8s_monitoring_ok
 530     fi
 531
 532     [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
 533     track osmclient osmclient_ok
 534
 535     echo -e "Checking OSM health state..."
 536     $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_NAMESPACE} -k || \
 537     (echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
 538     echo -e "Check OSM status with: kubectl -n ${OSM_NAMESPACE} get all" && \
 539     track healthchecks osm_unhealthy didnotconverge)
 540     track healthchecks after_healthcheck_ok
 541
 542     add_local_k8scluster
 543     track final_ops add_local_k8scluster_ok
 544
 545     # if lxd is requested, iptables firewall is updated to work with both docker and LXD
 546     if [ -n "$INSTALL_LXD" ]; then
 547         arrange_docker_default_network_policy
 548     fi
 549
 550     wget -q -O- https://osm-download.etsi.org/ftp/osm-15.0-fifteen/README2.txt &> /dev/null
 551     track end
 552     sudo find /etc/osm
 553     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 554     return 0
 555 }
 556
 557 function install_to_openstack() {
 558     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 559
 560     if [ -z "$2" ]; then
 561         FATAL "OpenStack installer requires a valid external network name"
 562     fi
 563
 564     # Install Pip for Python3
 565     sudo apt install -y python3-pip python3-venv
 566     sudo -H LC_ALL=C python3 -m pip install -U pip
 567
 568     # Create a venv to avoid conflicts with the host installation
 569     python3 -m venv $OPENSTACK_PYTHON_VENV
 570
 571     source $OPENSTACK_PYTHON_VENV/bin/activate
 572
 573     # Install Ansible, OpenStack client and SDK, latest openstack version supported is Train
 574     python -m pip install -U wheel
 575     python -m pip install -U "python-openstackclient<=4.0.2" "openstacksdk>=0.12.0,<=0.36.2" "ansible>=2.10,<2.11"
 576
 577     # Install the Openstack cloud module (ansible>=2.10)
 578     ansible-galaxy collection install openstack.cloud
 579
 580     export ANSIBLE_CONFIG="$OSM_DEVOPS/installers/openstack/ansible.cfg"
 581
 582     OSM_INSTALLER_ARGS="${REPO_ARGS[@]}"
 583
 584     ANSIBLE_VARS="external_network_name=$2 setup_volume=$3 server_name=$OPENSTACK_VM_NAME"
 585
 586     if [ -n "$OPENSTACK_SSH_KEY_FILE" ]; then
 587         ANSIBLE_VARS+=" key_file=$OPENSTACK_SSH_KEY_FILE"
 588     fi
 589
 590     if [ -n "$OPENSTACK_USERDATA_FILE" ]; then
 591         ANSIBLE_VARS+=" userdata_file=$OPENSTACK_USERDATA_FILE"
 592     fi
 593
 594     # Execute the Ansible playbook based on openrc or clouds.yaml
 595     if [ -e "$1" ]; then
 596         . $1
 597         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 598         $OSM_DEVOPS/installers/openstack/site.yml
 599     else
 600         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 601         -e cloud_name=$1 $OSM_DEVOPS/installers/openstack/site.yml
 602     fi
 603
 604     # Exit from venv
 605     deactivate
 606
 607     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 608     return 0
 609 }
 610
 611 function arrange_docker_default_network_policy() {
 612     echo -e "Fixing firewall so docker and LXD can share the same host without affecting each other."
 613     sudo iptables -I DOCKER-USER -j ACCEPT
 614     sudo iptables-save | sudo tee /etc/iptables/rules.v4
 615     sudo ip6tables-save | sudo tee /etc/iptables/rules.v6
 616 }
 617
 618 function install_k8s_monitoring() {
 619     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 620     # install OSM monitoring
 621     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"
 622     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 623 }
 624
 625 function dump_vars(){
 626     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 627     echo "APT_PROXY_URL=$APT_PROXY_URL"
 628     echo "K8S_CLUSTER_ENGINE=$K8S_CLUSTER_ENGINE"
 629     echo "DEBUG_INSTALL=$DEBUG_INSTALL"
 630     echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL"
 631     echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL"
 632     echo "DOCKER_USER=$DOCKER_USER"
 633     echo "INSTALL_CACHELXDIMAGES=$INSTALL_CACHELXDIMAGES"
 634     echo "INSTALL_JUJU=$INSTALL_JUJU"
 635     echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
 636     echo "INSTALL_LXD=$INSTALL_LXD"
 637     echo "INSTALL_NGSA=$INSTALL_NGSA"
 638     echo "INSTALL_DOCKER=$INSTALL_DOCKER"
 639     echo "INSTALL_ONLY=$INSTALL_ONLY"
 640     echo "INSTALL_ONLY_DEPLOY_OSM=$INSTALL_ONLY_DEPLOY_OSM"
 641     echo "INSTALL_ONLY_DOCKER_CE=$INSTALL_ONLY_DOCKER_CE"
 642     echo "INSTALL_ONLY_K8S_CLUSTER=$INSTALL_ONLY_K8S_CLUSTER"
 643     echo "INSTALL_ONLY_NGSA=$INSTALL_ONLY_NGSA"
 644     echo "INSTALL_PLA=$INSTALL_PLA"
 645     echo "INSTALL_TO_OPENSTACK=$INSTALL_TO_OPENSTACK"
 646     echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
 647     echo "NO_HOST_PORTS=$NO_HOST_PORTS"
 648     echo "OPENSTACK_PUBLIC_NET_NAME=$OPENSTACK_PUBLIC_NET_NAME"
 649     echo "OPENSTACK_OPENRC_FILE_OR_CLOUD=$OPENSTACK_OPENRC_FILE_OR_CLOUD"
 650     echo "OPENSTACK_ATTACH_VOLUME=$OPENSTACK_ATTACH_VOLUME"
 651     echo "OPENSTACK_SSH_KEY_FILE"="$OPENSTACK_SSH_KEY_FILE"
 652     echo "OPENSTACK_USERDATA_FILE"="$OPENSTACK_USERDATA_FILE"
 653     echo "OPENSTACK_VM_NAME"="$OPENSTACK_VM_NAME"
 654     echo "OSM_DEVOPS=$OSM_DEVOPS"
 655     echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
 656     echo "OSM_HELM_WORK_DIR=$OSM_HELM_WORK_DIR"
 657     echo "OSM_NAMESPACE=$OSM_NAMESPACE"
 658     echo "OSM_VCA_HOST=$OSM_VCA_HOST"
 659     echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
 660     echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
 661     echo "OSM_WORK_DIR=$OSM_WORK_DIR"
 662     echo "PULL_IMAGES=$PULL_IMAGES"
 663     echo "RECONFIGURE=$RECONFIGURE"
 664     echo "RELEASE=$RELEASE"
 665     echo "REPOSITORY=$REPOSITORY"
 666     echo "REPOSITORY_BASE=$REPOSITORY_BASE"
 667     echo "REPOSITORY_KEY=$REPOSITORY_KEY"
 668     echo "SHOWOPTS=$SHOWOPTS"
 669     echo "TEST_INSTALLER=$TEST_INSTALLER"
 670     echo "UNINSTALL=$UNINSTALL"
 671     echo "UPDATE=$UPDATE"
 672     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 673 }
 674
 675 function parse_docker_registry_url() {
 676     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 677     DOCKER_REGISTRY_USER=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}')
 678     DOCKER_REGISTRY_PASSWORD=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}')
 679     DOCKER_REGISTRY_URL=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); print a[2]}')
 680     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 681 }
 682
 683 function ctrl_c() {
 684     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 685     echo "** Trapped CTRL-C"
 686     FATAL "User stopped the installation"
 687     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 688 }
 689
 690 UNINSTALL=""
 691 UPDATE=""
 692 RECONFIGURE=""
 693 TEST_INSTALLER=""
 694 INSTALL_LXD=""
 695 SHOWOPTS=""
 696 ASSUME_YES=""
 697 APT_PROXY_URL=""
 698 K8S_CLUSTER_ENGINE="k3s"
 699 DEBUG_INSTALL=""
 700 RELEASE="testing-daily"
 701 REPOSITORY="testing"
 702 INSTALL_K8S_MONITOR=""
 703 INSTALL_NGSA="y"
 704 INSTALL_PLA=""
 705 INSTALL_VIMEMU=""
 706 LXD_REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/lxd"
 707 LXD_REPOSITORY_PATH=""
 708 INSTALL_TO_OPENSTACK=""
 709 OPENSTACK_OPENRC_FILE_OR_CLOUD=""
 710 OPENSTACK_PUBLIC_NET_NAME=""
 711 OPENSTACK_ATTACH_VOLUME="false"
 712 OPENSTACK_SSH_KEY_FILE=""
 713 OPENSTACK_USERDATA_FILE=""
 714 OPENSTACK_VM_NAME="server-osm"
 715 OPENSTACK_PYTHON_VENV="$HOME/.virtual-envs/osm"
 716 INSTALL_ONLY=""
 717 INSTALL_ONLY_DEPLOY_OSM=""
 718 INSTALL_ONLY_DOCKER_CE=""
 719 INSTALL_ONLY_K8S_CLUSTER=""
 720 INSTALL_ONLY_NGSA=""
 721 INSTALL_DOCKER=""
 722 INSTALL_JUJU=""
 723 INSTALL_NOHOSTCLIENT=""
 724 INSTALL_CACHELXDIMAGES=""
 725 OSM_DEVOPS=
 726 OSM_VCA_HOST=
 727 OSM_VCA_SECRET=
 728 OSM_VCA_PUBKEY=
 729 OSM_VCA_CLOUDNAME="localhost"
 730 OSM_VCA_K8S_CLOUDNAME="k8scloud"
 731 OSM_NAMESPACE=osm
 732 NO_HOST_PORTS=""
 733 REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
 734 REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian"
 735 OSM_WORK_DIR="/etc/osm"
 736 OSM_HELM_WORK_DIR="${OSM_WORK_DIR}/helm"
 737 OSM_HOST_VOL="/var/lib/osm"
 738 OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_NAMESPACE}"
 739 OSM_DOCKER_TAG="testing-daily"
 740 DOCKER_USER=opensourcemano
 741 PULL_IMAGES="y"
 742 KAFKA_TAG=2.11-1.0.2
 743 KIWIGRID_K8S_SIDECAR_TAG="1.15.6"
 744 PROMETHEUS_TAG=v2.28.1
 745 GRAFANA_TAG=8.1.1
 746 PROMETHEUS_NODE_EXPORTER_TAG=0.18.1
 747 PROMETHEUS_CADVISOR_TAG=latest
 748 KEYSTONEDB_TAG=10
 749 OSM_DATABASE_COMMONKEY=
 750 ELASTIC_VERSION=6.4.2
 751 ELASTIC_CURATOR_VERSION=5.5.4
 752 POD_NETWORK_CIDR=10.244.0.0/16
 753 K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
 754 RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
 755 DOCKER_REGISTRY_URL=
 756 DOCKER_PROXY_URL=
 757 MODULE_DOCKER_TAG=
 758 OSM_INSTALLATION_TYPE="Default"
 759
 760 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
 761     case "${o}" in
 762         a)
 763             APT_PROXY_URL=${OPTARG}
 764             ;;
 765         c)
 766             K8S_CLUSTER_ENGINE=${OPTARG}
 767             [ "${K8S_CLUSTER_ENGINE}" == "kubeadm" ] && continue
 768             [ "${K8S_CLUSTER_ENGINE}" == "k3s" ] && continue
 769             echo -e "Invalid argument for -c : ' ${K8S_CLUSTER_ENGINE}'\n" >&2
 770             usage && exit 1
 771             ;;
 772         r)
 773             REPOSITORY="${OPTARG}"
 774             REPO_ARGS+=(-r "$REPOSITORY")
 775             ;;
 776         k)
 777             REPOSITORY_KEY="${OPTARG}"
 778             REPO_ARGS+=(-k "$REPOSITORY_KEY")
 779             ;;
 780         u)
 781             REPOSITORY_BASE="${OPTARG}"
 782             REPO_ARGS+=(-u "$REPOSITORY_BASE")
 783             ;;
 784         R)
 785             RELEASE="${OPTARG}"
 786             REPO_ARGS+=(-R "$RELEASE")
 787             ;;
 788         D)
 789             OSM_DEVOPS="${OPTARG}"
 790             ;;
 791         o)
 792             INSTALL_ONLY="y"
 793             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
 794             [ "${OPTARG}" == "ng-sa" ] && INSTALL_ONLY_NGSA="y" && continue
 795             [ "${OPTARG}" == "docker" ] && INSTALL_ONLY_DOCKER_CE="y" && continue
 796             [ "${OPTARG}" == "k8scluster" ] && INSTALL_ONLY_K8S_CLUSTER="y" && continue
 797             [ "${OPTARG}" == "deploy-osm" ] && INSTALL_ONLY_DEPLOY_OSM="y" && continue
 798             ;;
 799         O)
 800             INSTALL_TO_OPENSTACK="y"
 801             if [ -n "${OPTARG}" ]; then
 802                 OPENSTACK_OPENRC_FILE_OR_CLOUD="${OPTARG}"
 803             else
 804                 echo -e "Invalid argument for -O : ' $OPTARG'\n" >&2
 805                 usage && exit 1
 806             fi
 807             ;;
 808         f)
 809             OPENSTACK_SSH_KEY_FILE="${OPTARG}"
 810             ;;
 811         F)
 812             OPENSTACK_USERDATA_FILE="${OPTARG}"
 813             ;;
 814         N)
 815             OPENSTACK_PUBLIC_NET_NAME="${OPTARG}"
 816             ;;
 817         H)
 818             OSM_VCA_HOST="${OPTARG}"
 819             ;;
 820         S)
 821             OSM_VCA_SECRET="${OPTARG}"
 822             ;;
 823         s)
 824             OSM_NAMESPACE="${OPTARG}" && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
 825             ;;
 826         t)
 827             OSM_DOCKER_TAG="${OPTARG}"
 828             REPO_ARGS+=(-t "$OSM_DOCKER_TAG")
 829             ;;
 830         U)
 831             DOCKER_USER="${OPTARG}"
 832             ;;
 833         P)
 834             OSM_VCA_PUBKEY=$(cat ${OPTARG})
 835             ;;
 836         A)
 837             OSM_VCA_APIPROXY="${OPTARG}"
 838             ;;
 839         l)
 840             LXD_CLOUD_FILE="${OPTARG}"
 841             ;;
 842         L)
 843             LXD_CRED_FILE="${OPTARG}"
 844             ;;
 845         K)
 846             CONTROLLER_NAME="${OPTARG}"
 847             ;;
 848         d)
 849             DOCKER_REGISTRY_URL="${OPTARG}"
 850             ;;
 851         p)
 852             DOCKER_PROXY_URL="${OPTARG}"
 853             ;;
 854         T)
 855             MODULE_DOCKER_TAG="${OPTARG}"
 856             ;;
 857         -)
 858             [ "${OPTARG}" == "help" ] && usage && exit 0
 859             [ "${OPTARG}" == "debug" ] && DEBUG_INSTALL="--debug" && continue
 860             [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue
 861             [ "${OPTARG}" == "update" ] && UPDATE="y" && continue
 862             [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE="y" && continue
 863             [ "${OPTARG}" == "test" ] && TEST_INSTALLER="y" && continue
 864             [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD="y" && continue
 865             [ "${OPTARG}" == "lxd" ] && INSTALL_LXD="y" && continue
 866             [ "${OPTARG}" == "nolxd" ] && INSTALL_LXD="" && continue
 867             [ "${OPTARG}" == "docker" ] && INSTALL_DOCKER="y" && continue
 868             [ "${OPTARG}" == "nodocker" ] && INSTALL_DOCKER="" && continue
 869             [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue
 870             [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS="y" && continue
 871             [ "${OPTARG}" == "juju" ] && INSTALL_JUJU="y" && continue
 872             [ "${OPTARG}" == "nojuju" ] && INSTALL_JUJU="" && continue
 873             [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue
 874             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
 875             [ "${OPTARG}" == "charmed" ] && CHARMED="y" && OSM_INSTALLATION_TYPE="Charmed" && continue
 876             [ "${OPTARG}" == "bundle" ] && continue
 877             [ "${OPTARG}" == "k8s" ] && continue
 878             [ "${OPTARG}" == "lxd-cred" ] && continue
 879             [ "${OPTARG}" == "microstack" ] && continue
 880             [ "${OPTARG}" == "overlay" ] && continue
 881             [ "${OPTARG}" == "only-vca" ] && continue
 882             [ "${OPTARG}" == "small-profile" ] && continue
 883             [ "${OPTARG}" == "vca" ] && continue
 884             [ "${OPTARG}" == "ha" ] && continue
 885             [ "${OPTARG}" == "tag" ] && continue
 886             [ "${OPTARG}" == "registry" ] && continue
 887             [ "${OPTARG}" == "pla" ] && INSTALL_PLA="y" && continue
 888             [ "${OPTARG}" == "old-sa" ] && INSTALL_NGSA="" && continue
 889             [ "${OPTARG}" == "ng-sa" ] && INSTALL_NGSA="y" && continue
 890             [ "${OPTARG}" == "volume" ] && OPENSTACK_ATTACH_VOLUME="true" && continue
 891             [ "${OPTARG}" == "nocachelxdimages" ] && continue
 892             [ "${OPTARG}" == "cachelxdimages" ] && INSTALL_CACHELXDIMAGES="--cachelxdimages" && continue
 893             echo -e "Invalid option: '--$OPTARG'\n" >&2
 894             usage && exit 1
 895             ;;
 896         :)
 897             echo "Option -$OPTARG requires an argument" >&2
 898             usage && exit 1
 899             ;;
 900         \?)
 901             echo -e "Invalid option: '-$OPTARG'\n" >&2
 902             usage && exit 1
 903             ;;
 904         h)
 905             usage && exit 0
 906             ;;
 907         y)
 908             ASSUME_YES="y"
 909             ;;
 910         *)
 911             usage && exit 1
 912             ;;
 913     esac
 914 done
 915
 916 source $OSM_DEVOPS/common/all_funcs
 917
 918 [ -z "${DEBUG_INSTALL}" ] || DEBUG Debug is on
 919 [ -n "$SHOWOPTS" ] && dump_vars && exit 0
 920
 921 # Uninstall if "--uninstall"
 922 if [ -n "$UNINSTALL" ]; then
 923     if [ -n "$CHARMED" ]; then
 924         ${OSM_DEVOPS}/installers/charmed_uninstall.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D $OSM_DEVOPS -t $DOCKER_TAG "$@" || \
 925         FATAL_TRACK charmed_uninstall "charmed_uninstall.sh failed"
 926     else
 927         ${OSM_DEVOPS}/installers/uninstall_osm.sh "$@" || \
 928         FATAL_TRACK community_uninstall "uninstall_osm.sh failed"
 929     fi
 930     echo -e "\nDONE"
 931     exit 0
 932 fi
 933
 934 # Installation starts here
 935
 936 # Get README and create OSM_TRACK_INSTALLATION_ID
 937 wget -q -O- https://osm-download.etsi.org/ftp/osm-15.0-fifteen/README.txt &> /dev/null
 938 export OSM_TRACK_INSTALLATION_ID="$(date +%s)-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 16)"
 939
 940 # Get OS info to be tracked
 941 os_distro=$(lsb_release -i 2>/dev/null | awk '{print $3}')
 942 echo $os_distro
 943 os_release=$(lsb_release -r 2>/dev/null | awk '{print $2}')
 944 echo $os_release
 945 os_info="${os_distro}_${os_release}"
 946 os_info="${os_info// /_}"
 947
 948 if [ -n "$CHARMED" ]; then
 949     # Charmed installation
 950     sudo snap install jq || FATAL "Could not install jq (snap package). Make sure that snap works"
 951     ${OSM_DEVOPS}/installers/charmed_install.sh --tag $OSM_DOCKER_TAG "$@" || \
 952     FATAL_TRACK charmed_install "charmed_install.sh failed"
 953     wget -q -O- https://osm-download.etsi.org/ftp/osm-15.0-fifteen/README2.txt &> /dev/null
 954     echo -e "\nDONE"
 955     exit 0
 956 elif [ -n "$INSTALL_TO_OPENSTACK" ]; then
 957     # Installation to Openstack
 958     install_to_openstack $OPENSTACK_OPENRC_FILE_OR_CLOUD $OPENSTACK_PUBLIC_NET_NAME $OPENSTACK_ATTACH_VOLUME
 959     echo -e "\nDONE"
 960     exit 0
 961 else
 962     # Community_installer
 963     # Special cases go first
 964     if [ -n "$INSTALL_ONLY" ]; then
 965         [ -n "$INSTALL_ONLY_DOCKER_CE" ] && install_docker_ce
 966         [ -n "$INSTALL_ONLY_K8S_CLUSTER" ] && install_k8s_cluster
 967         [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
 968         [ -n "$INSTALL_ONLY_DEPLOY_OSM" ] && deploy_osm
 969         [ -n "$INSTALL_ONLY_NGSA" ] && install_osm_ngsa_service
 970         echo -e "\nDONE" && exit 0
 971     fi
 972     # This is where installation starts
 973     install_osm
 974     echo -e "\nDONE"
 975     exit 0
 976 fi