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 from binaries or source code (by default, from binaries)"
  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 "     -b <refspec>:   install OSM from source code using a specific branch (master, v2.0, ...) or tag"
  28     echo -e "                     -b master          (main dev branch)"
  29     echo -e "                     -b v2.0            (v2.0 branch)"
  30     echo -e "                     -b tags/v1.1.0     (a specific tag)"
  31     echo -e "                     ..."
  32     echo -e "     -a <apt proxy url>: use this apt proxy url when downloading apt packages (air-gapped installation)"
  33     echo -e "     -s <stack name> or <namespace>  user defined stack name when installed using swarm or namespace when installed using k8s, default is osm"
  34     echo -e "     -H <VCA host>   use specific juju host controller IP"
  35     echo -e "     -S <VCA secret> use VCA/juju secret key"
  36     echo -e "     -P <VCA pubkey> use VCA/juju public key file"
  37     echo -e "     -A <VCA apiproxy> use VCA/juju API proxy"
  38     echo -e "     --pla:          install the PLA module for placement support"
  39     echo -e "     --ng-sa:        install Airflow and Pushgateway to get VNF and NS status (experimental)"
  40     echo -e "     -m <MODULE>:    install OSM but only rebuild or pull the specified docker images (NG-UI, NBI, LCM, RO, MON, POL, PLA, KAFKA, MONGO, PROMETHEUS, PROMETHEUS-CADVISOR, KEYSTONE-DB, NONE)"
  41     echo -e "     -o <ADDON>:     ONLY (un)installs one of the addons (k8s_monitor, ng-sa)"
  42     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/"
  43     echo -e "     -N <openstack public network name/ID>: Public network name required to setup OSM to OpenStack"
  44     echo -e "     -f <path to SSH public key>: Public SSH key to use to deploy OSM to OpenStack"
  45     echo -e "     -F <path to cloud-init file>: Cloud-Init userdata file to deploy OSM to OpenStack"
  46     echo -e "     -D <devops path> use local devops installation path"
  47     echo -e "     -w <work dir>   Location to store runtime installation"
  48     echo -e "     -t <docker tag> specify osm docker tag (default is latest)"
  49     echo -e "     -l:             LXD cloud yaml file"
  50     echo -e "     -L:             LXD credentials yaml file"
  51     echo -e "     -K:             Specifies the name of the controller to use - The controller must be already bootstrapped"
  52     echo -e "     -d <docker registry URL> use docker registry URL instead of dockerhub"
  53     echo -e "     -p <docker proxy URL> set docker proxy URL as part of docker CE configuration"
  54     echo -e "     -T <docker tag> specify docker tag for the modules specified with option -m"
  55     echo -e "     --debug:        debug mode"
  56     echo -e "     --nocachelxdimages:  do not cache local lxd images, do not create cronjob for that cache (will save installation time, might affect instantiation time)"
  57     echo -e "     --cachelxdimages:  cache local lxd images, create cronjob for that cache (will make installation longer)"
  58     echo -e "     --nolxd:        do not install and configure LXD, allowing unattended installations (assumes LXD is already installed and confifured)"
  59     echo -e "     --nodocker:     do not install docker, do not initialize a swarm (assumes docker is already installed and a swarm has been initialized)"
  60     echo -e "     --nojuju:       do not juju, assumes already installed"
  61     echo -e "     --nodockerbuild:do not build docker images (use existing locally cached images)"
  62     echo -e "     --nohostports:  do not expose docker ports to host (useful for creating multiple instances of osm on the same host)"
  63     echo -e "     --nohostclient: do not install the osmclient"
  64     echo -e "     --uninstall:    uninstall OSM: remove the containers and delete NAT rules"
  65     echo -e "     --source:       install OSM from source code using the latest stable tag"
  66     echo -e "     --develop:      (deprecated, use '-b master') install OSM from source code using the master branch"
  67     echo -e "     --pullimages:   pull/run osm images from docker.io/opensourcemano"
  68     echo -e "     --k8s_monitor:  install the OSM kubernetes monitoring with prometheus and grafana"
  69     echo -e "     --volume:       create a VM volume when installing to OpenStack"
  70     echo -e "     --showopts:     print chosen options and exit (only for debugging)"
  71     echo -e "     --charmed:                   Deploy and operate OSM with Charms on k8s"
  72     echo -e "     [--bundle <bundle path>]:    Specify with which bundle to deploy OSM with charms (--charmed option)"
  73     echo -e "     [--k8s <kubeconfig path>]:   Specify with which kubernetes to deploy OSM with charms (--charmed option)"
  74     echo -e "     [--vca <name>]:              Specifies the name of the controller to use - The controller must be already bootstrapped (--charmed option)"
  75     echo -e "     [--small-profile]:           Do not install and configure LXD which aims to use only K8s Clouds (--charmed option)"
  76     echo -e "     [--lxd <yaml path>]:         Takes a YAML file as a parameter with the LXD Cloud information (--charmed option)"
  77     echo -e "     [--lxd-cred <yaml path>]:    Takes a YAML file as a parameter with the LXD Credentials information (--charmed option)"
  78     echo -e "     [--microstack]:              Installs microstack as a vim. (--charmed option)"
  79     echo -e "     [--overlay]:                 Add an overlay to override some defaults of the default bundle (--charmed option)"
  80     echo -e "     [--ha]:                      Installs High Availability bundle. (--charmed option)"
  81     echo -e "     [--tag]:                     Docker image tag. (--charmed option)"
  82     echo -e "     [--registry]:                Docker registry with optional credentials as user:pass@hostname:port (--charmed option)"
  83     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
  84 }
  85
  86 # takes a juju/accounts.yaml file and returns the password specific
  87 # for a controller. I wrote this using only bash tools to minimize
  88 # additions of other packages
  89 function parse_juju_password {
  90     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
  91     password_file="${HOME}/.local/share/juju/accounts.yaml"
  92     local controller_name=$1
  93     local s='[[:space:]]*' w='[a-zA-Z0-9_-]*' fs=$(echo @|tr @ '\034')
  94     sed -ne "s|^\($s\):|\1|" \
  95          -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
  96          -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p" $password_file |
  97     awk -F$fs -v controller=$controller_name '{
  98         indent = length($1)/2;
  99         vname[indent] = $2;
 100         for (i in vname) {if (i > indent) {delete vname[i]}}
 101         if (length($3) > 0) {
 102             vn=""; for (i=0; i<indent; i++) {vn=(vn)(vname[i])("_")}
 103             if (match(vn,controller) && match($2,"password")) {
 104                 printf("%s",$3);
 105             }
 106         }
 107     }'
 108     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 109 }
 110
 111 function set_vca_variables() {
 112     OSM_VCA_CLOUDNAME="lxd-cloud"
 113     [ -n "$OSM_VCA_HOST" ] && OSM_VCA_CLOUDNAME="localhost"
 114     if [ -z "$OSM_VCA_HOST" ]; then
 115         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`sg lxd -c "juju show-controller $OSM_STACK_NAME"|grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
 116         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`juju show-controller $CONTROLLER_NAME |grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
 117         [ -z "$OSM_VCA_HOST" ] && FATAL "Cannot obtain juju controller IP address"
 118     fi
 119     if [ -z "$OSM_VCA_SECRET" ]; then
 120         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $OSM_STACK_NAME)
 121         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $CONTROLLER_NAME)
 122         [ -z "$OSM_VCA_SECRET" ] && FATAL "Cannot obtain juju secret"
 123     fi
 124     if [ -z "$OSM_VCA_PUBKEY" ]; then
 125         OSM_VCA_PUBKEY=$(cat $HOME/.local/share/juju/ssh/juju_id_rsa.pub)
 126         [ -z "$OSM_VCA_PUBKEY" ] && FATAL "Cannot obtain juju public key"
 127     fi
 128     if [ -z "$OSM_VCA_CACERT" ]; then
 129         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $OSM_STACK_NAME '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
 130         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $CONTROLLER_NAME '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
 131         [ -z "$OSM_VCA_CACERT" ] && FATAL "Cannot obtain juju CA certificate"
 132     fi
 133 }
 134
 135 function generate_secret() {
 136     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 137     head /dev/urandom | tr -dc A-Za-z0-9 | head -c 32
 138     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 139 }
 140
 141 function check_packages() {
 142     NEEDED_PACKAGES="$1"
 143     echo -e "Checking required packages: ${NEEDED_PACKAGES}"
 144     for PACKAGE in ${NEEDED_PACKAGES} ; do
 145         dpkg -L ${PACKAGE}
 146         if [ $? -ne 0 ]; then
 147             echo -e "Package ${PACKAGE} is not installed."
 148             echo -e "Updating apt-cache ..."
 149             sudo apt-get update
 150             echo -e "Installing ${PACKAGE} ..."
 151             sudo apt-get install -y ${PACKAGE} || FATAL "failed to install ${PACKAGE}"
 152         fi
 153     done
 154     echo -e "Required packages are present: ${NEEDED_PACKAGES}"
 155 }
 156
 157 function ask_user(){
 158     # ask to the user and parse a response among 'y', 'yes', 'n' or 'no'. Case insensitive
 159     # Params: $1 text to ask;   $2 Action by default, can be 'y' for yes, 'n' for no, other or empty for not allowed
 160     # Return: true(0) if user type 'yes'; false (1) if user type 'no'
 161     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 162     read -e -p "$1" USER_CONFIRMATION
 163     while true ; do
 164         [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'y' ] && return 0
 165         [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'n' ] && return 1
 166         [ "${USER_CONFIRMATION,,}" == "yes" ] || [ "${USER_CONFIRMATION,,}" == "y" ] && return 0
 167         [ "${USER_CONFIRMATION,,}" == "no" ]  || [ "${USER_CONFIRMATION,,}" == "n" ] && return 1
 168         read -e -p "Please type 'yes' or 'no': " USER_CONFIRMATION
 169     done
 170     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 171 }
 172
 173 function install_osmclient(){
 174     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 175     CLIENT_RELEASE=${RELEASE#"-R "}
 176     CLIENT_REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
 177     CLIENT_REPOSITORY=${REPOSITORY#"-r "}
 178     CLIENT_REPOSITORY_BASE=${REPOSITORY_BASE#"-u "}
 179     key_location=$CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE/$CLIENT_REPOSITORY_KEY
 180     curl $key_location | sudo APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE=1 apt-key add -
 181     sudo add-apt-repository -y "deb [arch=amd64] $CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE $CLIENT_REPOSITORY osmclient IM"
 182     sudo apt-get update
 183     sudo apt-get install -y python3-pip
 184     sudo -H LC_ALL=C python3 -m pip install -U pip
 185     sudo -H LC_ALL=C python3 -m pip install -U python-magic pyangbind verboselogs
 186     sudo apt-get install -y python3-osm-im python3-osmclient
 187     if [ -f /usr/lib/python3/dist-packages/osm_im/requirements.txt ]; then
 188         python3 -m pip install -r /usr/lib/python3/dist-packages/osm_im/requirements.txt
 189     fi
 190     if [ -f /usr/lib/python3/dist-packages/osmclient/requirements.txt ]; then
 191         sudo apt-get install -y libcurl4-openssl-dev libssl-dev libmagic1
 192         python3 -m pip install -r /usr/lib/python3/dist-packages/osmclient/requirements.txt
 193     fi
 194     [ -z "$INSTALL_LIGHTWEIGHT" ] && export OSM_HOSTNAME=`lxc list | awk '($2=="SO-ub"){print $6}'`
 195     [ -z "$INSTALL_LIGHTWEIGHT" ] && export OSM_RO_HOSTNAME=`lxc list | awk '($2=="RO"){print $6}'`
 196     echo -e "\nOSM client installed"
 197     if [ -z "$INSTALL_LIGHTWEIGHT" ]; then
 198         echo -e "You might be interested in adding the following OSM client env variables to your .bashrc file:"
 199         echo "     export OSM_HOSTNAME=${OSM_HOSTNAME}"
 200         echo "     export OSM_RO_HOSTNAME=${OSM_RO_HOSTNAME}"
 201     else
 202         echo -e "OSM client assumes that OSM host is running in localhost (127.0.0.1)."
 203         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:"
 204         echo "     export OSM_HOSTNAME=<OSM_host>"
 205     fi
 206     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 207     return 0
 208 }
 209
 210 function docker_login() {
 211     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 212     echo "Docker login"
 213     [ -z "${DEBUG_INSTALL}" ] || DEBUG "Docker registry user: ${DOCKER_REGISTRY_USER}"
 214     sg docker -c "docker login -u ${DOCKER_REGISTRY_USER} -p ${DOCKER_REGISTRY_PASSWORD} --password-stdin"
 215     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 216 }
 217
 218 function generate_docker_images() {
 219     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 220     echo "Pulling and generating docker images"
 221     [ -n "${DOCKER_REGISTRY_URL}" ] && docker_login
 222
 223     echo "Pulling docker images"
 224
 225     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q KAFKA ; then
 226         sg docker -c "docker pull wurstmeister/zookeeper" || FATAL "cannot get zookeeper docker image"
 227         sg docker -c "docker pull wurstmeister/kafka:${KAFKA_TAG}" || FATAL "cannot get kafka docker image"
 228     fi
 229
 230     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS ; then
 231         sg docker -c "docker pull prom/prometheus:${PROMETHEUS_TAG}" || FATAL "cannot get prometheus docker image"
 232     fi
 233
 234     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS-CADVISOR ; then
 235         sg docker -c "docker pull google/cadvisor:${PROMETHEUS_CADVISOR_TAG}" || FATAL "cannot get prometheus cadvisor docker image"
 236     fi
 237
 238     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q GRAFANA ; then
 239         sg docker -c "docker pull grafana/grafana:${GRAFANA_TAG}" || FATAL "cannot get grafana docker image"
 240         sg docker -c "docker pull kiwigrid/k8s-sidecar:${KIWIGRID_K8S_SIDECAR_TAG}" || FATAL "cannot get kiwigrid k8s-sidecar docker image"
 241     fi
 242
 243     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q NBI || echo $TO_REBUILD | grep -q KEYSTONE-DB ; then
 244         sg docker -c "docker pull mariadb:${KEYSTONEDB_TAG}" || FATAL "cannot get keystone-db docker image"
 245     fi
 246
 247     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q RO ; then
 248         sg docker -c "docker pull mysql:5" || FATAL "cannot get mysql docker image"
 249     fi
 250
 251     if [ -n "$PULL_IMAGES" ]; then
 252         echo "Pulling OSM docker images"
 253         for module in MON POL NBI KEYSTONE RO LCM NG-UI PLA osmclient; do
 254             module_lower=${module,,}
 255             if [ $module == "PLA" -a ! -n "$INSTALL_PLA" ]; then
 256                 continue
 257             fi
 258             module_tag="${OSM_DOCKER_TAG}"
 259             if [ -n "${MODULE_DOCKER_TAG}" ] && echo $TO_REBUILD | grep -q $module ; then
 260                 module_tag="${MODULE_DOCKER_TAG}"
 261             fi
 262             echo "Pulling ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module_lower}:${module_tag} docker image"
 263             sg docker -c "docker pull ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module_lower}:${module_tag}" || FATAL "cannot pull $module docker image"
 264         done
 265     else
 266         _build_from=$COMMIT_ID
 267         [ -z "$_build_from" ] && _build_from="latest"
 268         echo "OSM Docker images generated from $_build_from"
 269         LWTEMPDIR="$(mktemp -d -q --tmpdir "installosmlight.XXXXXX")"
 270         trap 'rm -rf "${LWTEMPDIR}"' EXIT
 271         for module in MON POL NBI KEYSTONE RO LCM NG-UI PLA; do
 272             if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q ${module} ; then
 273                 module_lower=${module,,}
 274                 if [ $module == "PLA" -a ! -n "$INSTALL_PLA" ]; then
 275                     continue
 276                 fi
 277                 git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/$module
 278                 git -C ${LWTEMPDIR}/${module} checkout ${COMMIT_ID}
 279                 sg docker -c "docker build ${LWTEMPDIR}/${module} -f ${LWTEMPDIR}/${module}/docker/Dockerfile -t ${DOCKER_USER}/${module_lower} --no-cache" || FATAL "cannot build ${module} docker image"
 280             fi
 281         done
 282         if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q osmclient; then
 283             BUILD_ARGS+=(--build-arg REPOSITORY="$REPOSITORY")
 284             BUILD_ARGS+=(--build-arg RELEASE="$RELEASE")
 285             BUILD_ARGS+=(--build-arg REPOSITORY_KEY="$REPOSITORY_KEY")
 286             BUILD_ARGS+=(--build-arg REPOSITORY_BASE="$REPOSITORY_BASE")
 287             sg docker -c "docker build -t ${DOCKER_USER}/osmclient ${BUILD_ARGS[@]} -f $OSM_DEVOPS/docker/osmclient ."
 288         fi
 289         echo "Finished generation of docker images"
 290     fi
 291
 292     echo "Finished pulling and generating docker images"
 293     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 294 }
 295
 296 function cmp_overwrite() {
 297     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 298     file1="$1"
 299     file2="$2"
 300     if ! $(cmp "${file1}" "${file2}" >/dev/null 2>&1); then
 301         if [ -f "${file2}" ]; then
 302             ask_user "The file ${file2} already exists. Overwrite (y/N)? " n && cp -b ${file1} ${file2}
 303         else
 304             cp -b ${file1} ${file2}
 305         fi
 306     fi
 307     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 308 }
 309
 310 function generate_k8s_manifest_files() {
 311     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 312     #Kubernetes resources
 313     sudo cp -bR ${OSM_DEVOPS}/installers/docker/osm_pods $OSM_DOCKER_WORK_DIR
 314     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 315 }
 316
 317 function generate_docker_env_files() {
 318     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 319     echo "Doing a backup of existing env files"
 320     sudo cp $OSM_DOCKER_WORK_DIR/keystone-db.env{,~}
 321     sudo cp $OSM_DOCKER_WORK_DIR/keystone.env{,~}
 322     sudo cp $OSM_DOCKER_WORK_DIR/lcm.env{,~}
 323     sudo cp $OSM_DOCKER_WORK_DIR/mon.env{,~}
 324     sudo cp $OSM_DOCKER_WORK_DIR/nbi.env{,~}
 325     sudo cp $OSM_DOCKER_WORK_DIR/pol.env{,~}
 326     sudo cp $OSM_DOCKER_WORK_DIR/ro-db.env{,~}
 327     sudo cp $OSM_DOCKER_WORK_DIR/ro.env{,~}
 328     if [ -n "${INSTALL_NGSA}" ]; then
 329         sudo cp $OSM_DOCKER_WORK_DIR/ngsa.env{,~}
 330     fi
 331
 332     echo "Generating docker env files"
 333     # LCM
 334     if [ ! -f $OSM_DOCKER_WORK_DIR/lcm.env ]; then
 335         echo "OSMLCM_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 336     fi
 337
 338     if ! grep -Fq "OSMLCM_VCA_HOST" $OSM_DOCKER_WORK_DIR/lcm.env; then
 339         echo "OSMLCM_VCA_HOST=${OSM_VCA_HOST}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 340     else
 341         sudo sed -i "s|OSMLCM_VCA_HOST.*|OSMLCM_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/lcm.env
 342     fi
 343
 344     if ! grep -Fq "OSMLCM_VCA_SECRET" $OSM_DOCKER_WORK_DIR/lcm.env; then
 345         echo "OSMLCM_VCA_SECRET=${OSM_VCA_SECRET}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 346     else
 347         sudo sed -i "s|OSMLCM_VCA_SECRET.*|OSMLCM_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/lcm.env
 348     fi
 349
 350     if ! grep -Fq "OSMLCM_VCA_PUBKEY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 351         echo "OSMLCM_VCA_PUBKEY=${OSM_VCA_PUBKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 352     else
 353         sudo sed -i "s|OSMLCM_VCA_PUBKEY.*|OSMLCM_VCA_PUBKEY=${OSM_VCA_PUBKEY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 354     fi
 355
 356     if ! grep -Fq "OSMLCM_VCA_CACERT" $OSM_DOCKER_WORK_DIR/lcm.env; then
 357         echo "OSMLCM_VCA_CACERT=${OSM_VCA_CACERT}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 358     else
 359         sudo sed -i "s|OSMLCM_VCA_CACERT.*|OSMLCM_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 360     fi
 361
 362     if [ -n "$OSM_VCA_APIPROXY" ]; then
 363         if ! grep -Fq "OSMLCM_VCA_APIPROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 364             echo "OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 365         else
 366             sudo sed -i "s|OSMLCM_VCA_APIPROXY.*|OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 367         fi
 368     fi
 369
 370     if ! grep -Fq "OSMLCM_VCA_ENABLEOSUPGRADE" $OSM_DOCKER_WORK_DIR/lcm.env; then
 371         echo "# OSMLCM_VCA_ENABLEOSUPGRADE=false" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 372     fi
 373
 374     if ! grep -Fq "OSMLCM_VCA_APTMIRROR" $OSM_DOCKER_WORK_DIR/lcm.env; then
 375         echo "# OSMLCM_VCA_APTMIRROR=http://archive.ubuntu.com/ubuntu/" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 376     fi
 377
 378     if ! grep -Fq "OSMLCM_VCA_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env; then
 379         echo "OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 380     else
 381         sudo sed -i "s|OSMLCM_VCA_CLOUD.*|OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 382     fi
 383
 384     if ! grep -Fq "OSMLCM_VCA_K8S_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env; then
 385         echo "OSMLCM_VCA_K8S_CLOUD=${OSM_VCA_K8S_CLOUDNAME}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 386     else
 387         sudo sed -i "s|OSMLCM_VCA_K8S_CLOUD.*|OSMLCM_VCA_K8S_CLOUD=${OSM_VCA_K8S_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 388     fi
 389     if [ -n "${OSM_BEHIND_PROXY}" ]; then
 390         if ! grep -Fq "HTTP_PROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 391             echo "HTTP_PROXY=${HTTP_PROXY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 392         else
 393             sudo sed -i "s|HTTP_PROXY.*|HTTP_PROXY=${HTTP_PROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 394         fi
 395         if ! grep -Fq "HTTPS_PROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 396             echo "HTTPS_PROXY=${HTTPS_PROXY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 397         else
 398             sudo sed -i "s|HTTPS_PROXY.*|HTTPS_PROXY=${HTTPS_PROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 399         fi
 400         if ! grep -Fq "NO_PROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 401             echo "NO_PROXY=${NO_PROXY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 402         else
 403             sudo sed -i "s|NO_PROXY.*|NO_PROXY=${NO_PROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 404         fi
 405     fi
 406
 407     # RO
 408     MYSQL_ROOT_PASSWORD=$(generate_secret)
 409     if [ ! -f $OSM_DOCKER_WORK_DIR/ro-db.env ]; then
 410         echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/ro-db.env
 411     fi
 412     if [ ! -f $OSM_DOCKER_WORK_DIR/ro.env ]; then
 413         echo "RO_DB_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/ro.env
 414     fi
 415     if ! grep -Fq "OSMRO_DATABASE_COMMONKEY" $OSM_DOCKER_WORK_DIR/ro.env; then
 416         echo "OSMRO_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/ro.env
 417     fi
 418
 419     # Keystone
 420     KEYSTONE_DB_PASSWORD=$(generate_secret)
 421     SERVICE_PASSWORD=$(generate_secret)
 422     if [ ! -f $OSM_DOCKER_WORK_DIR/keystone-db.env ]; then
 423         echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/keystone-db.env
 424     fi
 425     if [ ! -f $OSM_DOCKER_WORK_DIR/keystone.env ]; then
 426         echo "ROOT_DB_PASSWORD=${MYSQL_ROOT_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/keystone.env
 427         echo "KEYSTONE_DB_PASSWORD=${KEYSTONE_DB_PASSWORD}" |sudo tee -a $OSM_DOCKER_WORK_DIR/keystone.env
 428         echo "SERVICE_PASSWORD=${SERVICE_PASSWORD}" |sudo tee -a $OSM_DOCKER_WORK_DIR/keystone.env
 429     fi
 430
 431     # NBI
 432     if [ ! -f $OSM_DOCKER_WORK_DIR/nbi.env ]; then
 433         echo "OSMNBI_AUTHENTICATION_SERVICE_PASSWORD=${SERVICE_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/nbi.env
 434         echo "OSMNBI_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/nbi.env
 435     fi
 436
 437     # MON
 438     if [ ! -f $OSM_DOCKER_WORK_DIR/mon.env ]; then
 439         echo "OSMMON_KEYSTONE_SERVICE_PASSWORD=${SERVICE_PASSWORD}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 440         echo "OSMMON_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 441         echo "OSMMON_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/mon" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 442     fi
 443
 444     if ! grep -Fq "OS_NOTIFIER_URI" $OSM_DOCKER_WORK_DIR/mon.env; then
 445         echo "OS_NOTIFIER_URI=http://${OSM_DEFAULT_IP}:8662" |sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 446     else
 447         sudo sed -i "s|OS_NOTIFIER_URI.*|OS_NOTIFIER_URI=http://$OSM_DEFAULT_IP:8662|g" $OSM_DOCKER_WORK_DIR/mon.env
 448     fi
 449
 450     if ! grep -Fq "OSMMON_VCA_HOST" $OSM_DOCKER_WORK_DIR/mon.env; then
 451         echo "OSMMON_VCA_HOST=${OSM_VCA_HOST}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 452     else
 453         sudo sed -i "s|OSMMON_VCA_HOST.*|OSMMON_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/mon.env
 454     fi
 455
 456     if ! grep -Fq "OSMMON_VCA_SECRET" $OSM_DOCKER_WORK_DIR/mon.env; then
 457         echo "OSMMON_VCA_SECRET=${OSM_VCA_SECRET}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 458     else
 459         sudo sed -i "s|OSMMON_VCA_SECRET.*|OSMMON_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/mon.env
 460     fi
 461
 462     if ! grep -Fq "OSMMON_VCA_CACERT" $OSM_DOCKER_WORK_DIR/mon.env; then
 463         echo "OSMMON_VCA_CACERT=${OSM_VCA_CACERT}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 464     else
 465         sudo sed -i "s|OSMMON_VCA_CACERT.*|OSMMON_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/mon.env
 466     fi
 467
 468     # POL
 469     if [ ! -f $OSM_DOCKER_WORK_DIR/pol.env ]; then
 470         echo "OSMPOL_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/pol" | sudo tee -a $OSM_DOCKER_WORK_DIR/pol.env
 471     fi
 472
 473     # NG-SA
 474     if [ -n "${INSTALL_NGSA}" ] && [ ! -f $OSM_DOCKER_WORK_DIR/ngsa.env ]; then
 475         echo "OSMMON_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/ngsa.env
 476     fi
 477
 478     echo "Finished generation of docker env files"
 479     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 480 }
 481
 482 #creates secrets from env files which will be used by containers
 483 function kube_secrets(){
 484     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 485     kubectl create ns $OSM_STACK_NAME
 486     kubectl create secret generic lcm-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/lcm.env
 487     kubectl create secret generic mon-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/mon.env
 488     kubectl create secret generic nbi-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/nbi.env
 489     kubectl create secret generic ro-db-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ro-db.env
 490     kubectl create secret generic ro-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ro.env
 491     kubectl create secret generic keystone-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/keystone.env
 492     kubectl create secret generic pol-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/pol.env
 493     if [ -n "${INSTALL_NGSA}" ]; then
 494         kubectl create secret generic ngsa-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ngsa.env
 495     fi
 496     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 497 }
 498
 499 #deploys osm pods and services
 500 function deploy_osm_services() {
 501     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 502     kubectl apply -n $OSM_STACK_NAME -f $OSM_K8S_WORK_DIR
 503     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 504 }
 505
 506 #deploy charmed services
 507 function deploy_charmed_services() {
 508     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 509     juju add-model $OSM_STACK_NAME $OSM_VCA_K8S_CLOUDNAME
 510     juju deploy ch:mongodb-k8s -m $OSM_STACK_NAME
 511     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 512 }
 513
 514 function deploy_osm_pla_service() {
 515     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 516     # corresponding to deploy_osm_services
 517     kubectl apply -n $OSM_STACK_NAME -f $OSM_DOCKER_WORK_DIR/osm_pla
 518     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 519 }
 520
 521 function install_osm_ngsa_service() {
 522     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 523     $OSM_DEVOPS/installers/install_ngsa.sh -d ${OSM_HELM_WORK_DIR} -D ${OSM_DEVOPS} -t ${OSM_DOCKER_TAG} ${DEBUG_INSTALL} || \
 524     FATAL_TRACK install_osm_ngsa_service "install_ngsa.sh failed"
 525     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 526 }
 527
 528 function parse_yaml() {
 529     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 530     TAG=$1
 531     shift
 532     services=$@
 533     for module in $services; do
 534         if [ "$module" == "pla" ]; then
 535             if [ -n "$INSTALL_PLA" ]; then
 536                 echo "Updating K8s manifest file from opensourcemano\/pla:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/pla:${TAG}"
 537                 sudo sed -i "s#opensourcemano/pla:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/pla:${TAG}#g" ${OSM_DOCKER_WORK_DIR}/osm_pla/pla.yaml
 538             fi
 539         else
 540             image=${module}
 541             if [ "$module" == "ng-prometheus" ]; then
 542                 image="prometheus"
 543             fi
 544             echo "Updating K8s manifest file from opensourcemano\/${image}:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/${image}:${TAG}"
 545             sudo sed -i "s#opensourcemano/${image}:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/${image}:${TAG}#g" ${OSM_K8S_WORK_DIR}/${module}.yaml
 546         fi
 547     done
 548     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 549 }
 550
 551 function update_manifest_files() {
 552     osm_services="nbi lcm ro pol mon ng-ui keystone pla prometheus ng-prometheus"
 553     list_of_services=""
 554     for module in $osm_services; do
 555         module_upper="${module^^}"
 556         if ! echo $TO_REBUILD | grep -q $module_upper ; then
 557             list_of_services="$list_of_services $module"
 558         fi
 559     done
 560     if [ ! "$OSM_DOCKER_TAG" == "13" ]; then
 561         parse_yaml $OSM_DOCKER_TAG $list_of_services
 562     fi
 563     if [ -n "$MODULE_DOCKER_TAG" ]; then
 564         parse_yaml $MODULE_DOCKER_TAG $list_of_services_to_rebuild
 565     fi
 566     # The manifest for prometheus is prometheus.yaml or ng-prometheus.yaml, depending on the installation option
 567     if [ -n "$INSTALL_NGSA" ]; then
 568         sudo rm -f ${OSM_K8S_WORK_DIR}/prometheus.yaml
 569     else
 570         sudo rm -f ${OSM_K8S_WORK_DIR}/ng-prometheus.yaml
 571     fi
 572     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 573 }
 574
 575 function namespace_vol() {
 576     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 577     # List of services with a volume mounted in path /var/lib/osm
 578     osm_services="mysql"
 579     for osm in $osm_services; do
 580         if [ -f "$OSM_K8S_WORK_DIR/$osm.yaml" ] ; then
 581             sudo sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_K8S_WORK_DIR/$osm.yaml
 582         fi
 583     done
 584     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 585 }
 586
 587 function add_local_k8scluster() {
 588     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 589     /usr/bin/osm --all-projects vim-create \
 590       --name _system-osm-vim \
 591       --account_type dummy \
 592       --auth_url http://dummy \
 593       --user osm --password osm --tenant osm \
 594       --description "dummy" \
 595       --config '{management_network_name: mgmt}'
 596     /usr/bin/osm --all-projects k8scluster-add \
 597       --creds ${HOME}/.kube/config \
 598       --vim _system-osm-vim \
 599       --k8s-nets '{"net1": null}' \
 600       --version '1.15' \
 601       --description "OSM Internal Cluster" \
 602       _system-osm-k8s
 603     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 604 }
 605
 606 function configure_apt_proxy() {
 607     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 608     OSM_APT_PROXY=$1
 609     OSM_APT_PROXY_FILE="/etc/apt/apt.conf.d/osm-apt"
 610     echo "Configuring apt proxy in file ${OSM_APT_PROXY_FILE}"
 611     if [ ! -f ${OSM_APT_PROXY_FILE} ]; then
 612         sudo bash -c "cat <<EOF > ${OSM_APT_PROXY}
 613 Acquire::http { Proxy \"${OSM_APT_PROXY}\"; }
 614 EOF"
 615     else
 616         sudo sed -i "s|Proxy.*|Proxy \"${OSM_APT_PROXY}\"; }|" ${OSM_APT_PROXY_FILE}
 617     fi
 618     sudo apt-get update || FATAL "Configured apt proxy, but couldn't run 'apt-get update'. Check ${OSM_APT_PROXY_FILE}"
 619     track prereq apt_proxy_configured_ok
 620     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 621 }
 622
 623 function ask_proceed() {
 624     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 625
 626     [ -z "$ASSUME_YES" ] && ! ask_user "The installation will do the following
 627     1. Install and configure LXD
 628     2. Install juju
 629     3. Install docker CE
 630     4. Disable swap space
 631     5. Install and initialize Kubernetes
 632     as pre-requirements.
 633     Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1
 634
 635     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 636 }
 637
 638 function check_osm_behind_proxy() {
 639     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 640
 641     export OSM_BEHIND_PROXY=""
 642     export OSM_PROXY_ENV_VARIABLES=""
 643     [ -n "${http_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "http_proxy=${http_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} http_proxy"
 644     [ -n "${https_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${https_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} https_proxy"
 645     [ -n "${HTTP_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "HTTP_PROXY=${HTTP_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTP_PROXY"
 646     [ -n "${HTTPS_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${HTTPS_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTPS_PROXY"
 647     [ -n "${no_proxy}" ] && echo "no_proxy=${no_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} no_proxy"
 648     [ -n "${NO_PROXY}" ] && echo "NO_PROXY=${NO_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} NO_PROXY"
 649
 650     echo "OSM_BEHIND_PROXY=${OSM_BEHIND_PROXY}"
 651     echo "OSM_PROXY_ENV_VARIABLES=${OSM_PROXY_ENV_VARIABLES}"
 652
 653     if [ -n "${OSM_BEHIND_PROXY}" ]; then
 654         [ -z "$ASSUME_YES" ] && ! ask_user "
 655 The following env variables have been found for the current user:
 656 ${OSM_PROXY_ENV_VARIABLES}.
 657
 658 This suggests that this machine is behind a proxy and a special configuration is required.
 659 The installer will install Docker CE, LXD and Juju to work behind a proxy using those
 660 env variables.
 661
 662 Take into account that the installer uses apt, curl, wget, docker, lxd, juju and snap.
 663 Depending on the program, the env variables to work behind a proxy might be different
 664 (e.g. http_proxy vs HTTP_PROXY).
 665
 666 For that reason, it is strongly recommended that at least http_proxy, https_proxy, HTTP_PROXY
 667 and HTTPS_PROXY are defined.
 668
 669 Finally, some of the programs (apt, snap) those programs are run as sudoer, requiring that
 670 those env variables are also set for root user. If you are not sure whether those variables
 671 are configured for the root user, you can stop the installation now.
 672
 673 Do you want to proceed with the installation (Y/n)? " y && echo "Cancelled!" && exit 1
 674     else
 675         echo "This machine is not behind a proxy"
 676     fi
 677
 678     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 679 }
 680
 681 function find_devops_folder() {
 682     if [ -z "$OSM_DEVOPS" ]; then
 683         if [ -n "$TEST_INSTALLER" ]; then
 684             echo -e "\nUsing local devops repo for OSM installation"
 685             OSM_DEVOPS="$(dirname $(realpath $(dirname $0)))"
 686         else
 687             echo -e "\nCreating temporary dir for OSM installation"
 688             OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")"
 689             trap 'rm -rf "$OSM_DEVOPS"' EXIT
 690             git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS
 691         fi
 692     fi
 693 }
 694
 695 function install_osm() {
 696     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 697
 698     trap ctrl_c INT
 699
 700     # TODO: move this under start
 701     [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url
 702
 703     check_osm_behind_proxy
 704     track checks proxy_ok
 705
 706     check_packages "git wget curl tar snapd"
 707
 708     sudo snap install jq || FATAL "Could not install jq (snap package). Make sure that snap works"
 709
 710     find_devops_folder
 711
 712     # TODO: the use of stacks come from docker-compose. We should probably remove
 713     [ "${OSM_STACK_NAME}" == "osm" ] || OSM_DOCKER_WORK_DIR="$OSM_WORK_DIR/stack/$OSM_STACK_NAME"
 714
 715     track start release $RELEASE none none docker_tag $OSM_DOCKER_TAG none none installation_type $OSM_INSTALLATION_TYPE none none
 716
 717     track checks checkingroot_ok
 718     [ "$USER" == "root" ] && FATAL "You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges."
 719     track checks noroot_ok
 720
 721     ask_proceed
 722     track checks proceed_ok
 723
 724     echo "Installing OSM"
 725
 726     echo "Determining IP address of the interface with the default route"
 727     [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}')
 728     [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
 729     [ -z "$OSM_DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0"
 730     OSM_DEFAULT_IP=`ip -o -4 a s ${OSM_DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]; exit}'`
 731     [ -z "$OSM_DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route"
 732
 733     # configure apt proxy
 734     [ -n "$APT_PROXY_URL" ] && configure_apt_proxy $APT_PROXY_URL
 735
 736     # if no host is passed in, we need to install lxd/juju, unless explicilty asked not to
 737     if [ -z "$OSM_VCA_HOST" ] && [ -z "$INSTALL_NOLXD" ] && [ -z "$LXD_CLOUD_FILE" ]; then
 738         LXD_INSTALL_OPTS="-D ${OSM_DEVOPS} -i ${OSM_DEFAULT_IF} ${DEBUG_INSTALL}"
 739         [ -n "${OSM_BEHIND_PROXY}" ] && LXD_INSTALL_OPTS="${LXD_INSTALL_OPTS} -P"
 740         $OSM_DEVOPS/installers/install_lxd.sh ${LXD_INSTALL_OPTS} || FATAL_TRACK lxd "install_lxd.sh failed"
 741     fi
 742
 743     track prereq prereqok_ok
 744
 745     if [ ! -n "$INSTALL_NODOCKER" ]; then
 746         DOCKER_CE_OPTS="-D ${OSM_DEVOPS} ${DEBUG_INSTALL}"
 747         [ -n "${DOCKER_PROXY_URL}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -p ${DOCKER_PROXY_URL}"
 748         [ -n "${OSM_BEHIND_PROXY}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -P"
 749         $OSM_DEVOPS/installers/install_docker_ce.sh ${DOCKER_CE_OPTS} || FATAL_TRACK docker_ce "install_docker_ce.sh failed"
 750     fi
 751
 752     track docker_ce docker_ce_ok
 753
 754     echo "Creating folders for installation"
 755     [ ! -d "$OSM_DOCKER_WORK_DIR" ] && sudo mkdir -p $OSM_DOCKER_WORK_DIR
 756     [ ! -d "$OSM_DOCKER_WORK_DIR/osm_pla" -a -n "$INSTALL_PLA" ] && sudo mkdir -p $OSM_DOCKER_WORK_DIR/osm_pla
 757     sudo cp -b $OSM_DEVOPS/installers/docker/cluster-config.yaml $OSM_DOCKER_WORK_DIR/cluster-config.yaml
 758
 759     $OSM_DEVOPS/installers/install_kubeadm_cluster.sh -i ${OSM_DEFAULT_IP} -d ${OSM_DOCKER_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL} || \
 760     FATAL_TRACK k8scluster "install_kubeadm_cluster.sh failed"
 761     track k8scluster k8scluster_ok
 762
 763     JUJU_OPTS="-D ${OSM_DEVOPS} -s ${OSM_STACK_NAME} -i ${OSM_DEFAULT_IP} ${DEBUG_INSTALL} ${INSTALL_NOJUJU} ${INSTALL_CACHELXDIMAGES}"
 764     [ -n "${OSM_VCA_HOST}" ] && JUJU_OPTS="$JUJU_OPTS -H ${OSM_VCA_HOST}"
 765     [ -n "${LXD_CLOUD_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -l ${LXD_CLOUD_FILE}"
 766     [ -n "${LXD_CRED_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -L ${LXD_CRED_FILE}"
 767     [ -n "${CONTROLLER_NAME}" ] && JUJU_OPTS="$JUJU_OPTS -K ${CONTROLLER_NAME}"
 768     [ -n "${OSM_BEHIND_PROXY}" ] && JUJU_OPTS="${JUJU_OPTS} -P"
 769     $OSM_DEVOPS/installers/install_juju.sh ${JUJU_OPTS} || FATAL_TRACK juju "install_juju.sh failed"
 770     set_vca_variables
 771     track juju juju_ok
 772
 773     if [ -z "$OSM_DATABASE_COMMONKEY" ]; then
 774         OSM_DATABASE_COMMONKEY=$(generate_secret)
 775         [ -z "OSM_DATABASE_COMMONKEY" ] && FATAL "Cannot generate common db secret"
 776     fi
 777
 778     # Deploy OSM services
 779     [ -z "$DOCKER_NOBUILD" ] && generate_docker_images
 780     track docker_images docker_images_ok
 781
 782     generate_k8s_manifest_files
 783     track osm_files manifest_files_ok
 784     generate_docker_env_files
 785     track osm_files env_files_ok
 786
 787     deploy_charmed_services
 788     track deploy_osm deploy_charmed_services_ok
 789     kube_secrets
 790     track deploy_osm kube_secrets_ok
 791     update_manifest_files
 792     track deploy_osm update_manifest_files_ok
 793     namespace_vol
 794     track deploy_osm namespace_vol_ok
 795     deploy_osm_services
 796     track deploy_osm deploy_osm_services_k8s_ok
 797     if [ -n "$INSTALL_PLA" ]; then
 798         # optional PLA install
 799         deploy_osm_pla_service
 800         track deploy_osm deploy_osm_pla_ok
 801     fi
 802     if [ -n "$INSTALL_K8S_MONITOR" ]; then
 803         # install OSM MONITORING
 804         install_k8s_monitoring
 805         track deploy_osm install_k8s_monitoring_ok
 806     fi
 807     if [ -n "$INSTALL_NGSA" ]; then
 808         # optional PLA install
 809         install_osm_ngsa_service
 810         track deploy_osm install_osm_ngsa_ok
 811     fi
 812
 813     [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
 814     track osmclient osmclient_ok
 815
 816     echo -e "Checking OSM health state..."
 817     $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_STACK_NAME} -k || \
 818     (echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
 819     echo -e "Check OSM status with: kubectl -n ${OSM_STACK_NAME} get all" && \
 820     track healthchecks osm_unhealthy didnotconverge)
 821     track healthchecks after_healthcheck_ok
 822
 823     add_local_k8scluster
 824     track final_ops add_local_k8scluster_ok
 825
 826     wget -q -O- https://osm-download.etsi.org/ftp/osm-13.0-thirteen/README2.txt &> /dev/null
 827     track end
 828     sudo find /etc/osm
 829     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 830     return 0
 831 }
 832
 833 function install_to_openstack() {
 834     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 835
 836     if [ -z "$2" ]; then
 837         FATAL "OpenStack installer requires a valid external network name"
 838     fi
 839
 840     # Install Pip for Python3
 841     sudo apt install -y python3-pip python3-venv
 842     sudo -H LC_ALL=C python3 -m pip install -U pip
 843
 844     # Create a venv to avoid conflicts with the host installation
 845     python3 -m venv $OPENSTACK_PYTHON_VENV
 846
 847     source $OPENSTACK_PYTHON_VENV/bin/activate
 848
 849     # Install Ansible, OpenStack client and SDK, latest openstack version supported is Train
 850     python -m pip install -U wheel
 851     python -m pip install -U "python-openstackclient<=4.0.2" "openstacksdk>=0.12.0,<=0.36.2" "ansible>=2.10,<2.11"
 852
 853     # Install the Openstack cloud module (ansible>=2.10)
 854     ansible-galaxy collection install openstack.cloud
 855
 856     export ANSIBLE_CONFIG="$OSM_DEVOPS/installers/openstack/ansible.cfg"
 857
 858     OSM_INSTALLER_ARGS="${REPO_ARGS[@]}"
 859
 860     ANSIBLE_VARS="external_network_name=$2 setup_volume=$3 server_name=$OPENSTACK_VM_NAME"
 861
 862     if [ -n "$OPENSTACK_SSH_KEY_FILE" ]; then
 863         ANSIBLE_VARS+=" key_file=$OPENSTACK_SSH_KEY_FILE"
 864     fi
 865
 866     if [ -n "$OPENSTACK_USERDATA_FILE" ]; then
 867         ANSIBLE_VARS+=" userdata_file=$OPENSTACK_USERDATA_FILE"
 868     fi
 869
 870     # Execute the Ansible playbook based on openrc or clouds.yaml
 871     if [ -e "$1" ]; then
 872         . $1
 873         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 874         $OSM_DEVOPS/installers/openstack/site.yml
 875     else
 876         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 877         -e cloud_name=$1 $OSM_DEVOPS/installers/openstack/site.yml
 878     fi
 879
 880     # Exit from venv
 881     deactivate
 882
 883     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 884     return 0
 885 }
 886
 887 function install_k8s_monitoring() {
 888     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 889     # install OSM monitoring
 890     sudo chmod +x $OSM_DEVOPS/installers/k8s/*.sh
 891     sudo $OSM_DEVOPS/installers/k8s/install_osm_k8s_monitoring.sh || FATAL_TRACK install_k8s_monitoring "k8s/install_osm_k8s_monitoring.sh failed"
 892     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 893 }
 894
 895 function dump_vars(){
 896     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 897     echo "APT_PROXY_URL=$APT_PROXY_URL"
 898     echo "DEVELOP=$DEVELOP"
 899     echo "DEBUG_INSTALL=$DEBUG_INSTALL"
 900     echo "DOCKER_NOBUILD=$DOCKER_NOBUILD"
 901     echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL"
 902     echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL"
 903     echo "DOCKER_USER=$DOCKER_USER"
 904     echo "INSTALL_CACHELXDIMAGES=$INSTALL_CACHELXDIMAGES"
 905     echo "INSTALL_FROM_SOURCE=$INSTALL_FROM_SOURCE"
 906     echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
 907     echo "INSTALL_LIGHTWEIGHT=$INSTALL_LIGHTWEIGHT"
 908     echo "INSTALL_LXD=$INSTALL_LXD"
 909     echo "INSTALL_NGSA=$INSTALL_NGSA"
 910     echo "INSTALL_NODOCKER=$INSTALL_NODOCKER"
 911     echo "INSTALL_NOJUJU=$INSTALL_NOJUJU"
 912     echo "INSTALL_NOLXD=$INSTALL_NOLXD"
 913     echo "INSTALL_ONLY=$INSTALL_ONLY"
 914     echo "INSTALL_PLA=$INSTALL_PLA"
 915     echo "INSTALL_TO_OPENSTACK=$INSTALL_TO_OPENSTACK"
 916     echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
 917     echo "NO_HOST_PORTS=$NO_HOST_PORTS"
 918     echo "OPENSTACK_PUBLIC_NET_NAME=$OPENSTACK_PUBLIC_NET_NAME"
 919     echo "OPENSTACK_OPENRC_FILE_OR_CLOUD=$OPENSTACK_OPENRC_FILE_OR_CLOUD"
 920     echo "OPENSTACK_ATTACH_VOLUME=$OPENSTACK_ATTACH_VOLUME"
 921     echo "OPENSTACK_SSH_KEY_FILE"="$OPENSTACK_SSH_KEY_FILE"
 922     echo "OPENSTACK_USERDATA_FILE"="$OPENSTACK_USERDATA_FILE"
 923     echo "OPENSTACK_VM_NAME"="$OPENSTACK_VM_NAME"
 924     echo "OSM_DEVOPS=$OSM_DEVOPS"
 925     echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
 926     echo "OSM_DOCKER_WORK_DIR=$OSM_DOCKER_WORK_DIR"
 927     echo "OSM_HELM_WORK_DIR=$OSM_HELM_WORK_DIR"
 928     echo "OSM_K8S_WORK_DIR=$OSM_K8S_WORK_DIR"
 929     echo "OSM_STACK_NAME=$OSM_STACK_NAME"
 930     echo "OSM_VCA_HOST=$OSM_VCA_HOST"
 931     echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
 932     echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
 933     echo "OSM_WORK_DIR=$OSM_WORK_DIR"
 934     echo "PULL_IMAGES=$PULL_IMAGES"
 935     echo "RECONFIGURE=$RECONFIGURE"
 936     echo "RELEASE=$RELEASE"
 937     echo "REPOSITORY=$REPOSITORY"
 938     echo "REPOSITORY_BASE=$REPOSITORY_BASE"
 939     echo "REPOSITORY_KEY=$REPOSITORY_KEY"
 940     echo "SHOWOPTS=$SHOWOPTS"
 941     echo "TEST_INSTALLER=$TEST_INSTALLER"
 942     echo "TO_REBUILD=$TO_REBUILD"
 943     echo "UNINSTALL=$UNINSTALL"
 944     echo "UPDATE=$UPDATE"
 945     echo "Install from specific refspec (-b): $COMMIT_ID"
 946     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 947 }
 948
 949 function parse_docker_registry_url() {
 950     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 951     DOCKER_REGISTRY_USER=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}')
 952     DOCKER_REGISTRY_PASSWORD=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}')
 953     DOCKER_REGISTRY_URL=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); print a[2]}')
 954     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 955 }
 956
 957 function ctrl_c() {
 958     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 959     echo "** Trapped CTRL-C"
 960     FATAL "User stopped the installation"
 961     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 962 }
 963
 964 UNINSTALL=""
 965 DEVELOP=""
 966 UPDATE=""
 967 RECONFIGURE=""
 968 TEST_INSTALLER=""
 969 INSTALL_LXD=""
 970 SHOWOPTS=""
 971 COMMIT_ID=""
 972 ASSUME_YES=""
 973 APT_PROXY_URL=""
 974 INSTALL_FROM_SOURCE=""
 975 DEBUG_INSTALL=""
 976 RELEASE="ReleaseTEN"
 977 REPOSITORY="stable"
 978 INSTALL_K8S_MONITOR=""
 979 INSTALL_NGSA=""
 980 INSTALL_PLA=""
 981 INSTALL_VIMEMU=""
 982 LXD_REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/lxd"
 983 LXD_REPOSITORY_PATH=""
 984 INSTALL_LIGHTWEIGHT="y"
 985 INSTALL_TO_OPENSTACK=""
 986 OPENSTACK_OPENRC_FILE_OR_CLOUD=""
 987 OPENSTACK_PUBLIC_NET_NAME=""
 988 OPENSTACK_ATTACH_VOLUME="false"
 989 OPENSTACK_SSH_KEY_FILE=""
 990 OPENSTACK_USERDATA_FILE=""
 991 OPENSTACK_VM_NAME="server-osm"
 992 OPENSTACK_PYTHON_VENV="$HOME/.virtual-envs/osm"
 993 INSTALL_ONLY=""
 994 TO_REBUILD=""
 995 INSTALL_NOLXD=""
 996 INSTALL_NODOCKER=""
 997 INSTALL_NOJUJU=""
 998 INSTALL_NOHOSTCLIENT=""
 999 INSTALL_CACHELXDIMAGES=""
1000 OSM_DEVOPS=
1001 OSM_VCA_HOST=
1002 OSM_VCA_SECRET=
1003 OSM_VCA_PUBKEY=
1004 OSM_VCA_CLOUDNAME="localhost"
1005 OSM_VCA_K8S_CLOUDNAME="k8scloud"
1006 OSM_STACK_NAME=osm
1007 NO_HOST_PORTS=""
1008 DOCKER_NOBUILD=""
1009 REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
1010 REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian"
1011 OSM_WORK_DIR="/etc/osm"
1012 OSM_DOCKER_WORK_DIR="${OSM_WORK_DIR}/docker"
1013 OSM_K8S_WORK_DIR="${OSM_DOCKER_WORK_DIR}/osm_pods"
1014 OSM_HELM_WORK_DIR="${OSM_WORK_DIR}/helm"
1015 OSM_HOST_VOL="/var/lib/osm"
1016 OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1017 OSM_DOCKER_TAG=latest
1018 DOCKER_USER=opensourcemano
1019 PULL_IMAGES="y"
1020 KAFKA_TAG=2.11-1.0.2
1021 KIWIGRID_K8S_SIDECAR_TAG="1.15.6"
1022 PROMETHEUS_TAG=v2.28.1
1023 GRAFANA_TAG=8.1.1
1024 PROMETHEUS_NODE_EXPORTER_TAG=0.18.1
1025 PROMETHEUS_CADVISOR_TAG=latest
1026 KEYSTONEDB_TAG=10
1027 OSM_DATABASE_COMMONKEY=
1028 ELASTIC_VERSION=6.4.2
1029 ELASTIC_CURATOR_VERSION=5.5.4
1030 POD_NETWORK_CIDR=10.244.0.0/16
1031 K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
1032 RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
1033 DOCKER_REGISTRY_URL=
1034 DOCKER_PROXY_URL=
1035 MODULE_DOCKER_TAG=
1036 OSM_INSTALLATION_TYPE="Default"
1037
1038 while getopts ":a:b:r:n:k:u:R:D:o:O:m:N:H:S:s:t:U:P:A:l:L:K:d:p:T:f:F:-: hy" o; do
1039     case "${o}" in
1040         a)
1041             APT_PROXY_URL=${OPTARG}
1042             ;;
1043         b)
1044             COMMIT_ID=${OPTARG}
1045             PULL_IMAGES=""
1046             ;;
1047         r)
1048             REPOSITORY="${OPTARG}"
1049             REPO_ARGS+=(-r "$REPOSITORY")
1050             ;;
1051         k)
1052             REPOSITORY_KEY="${OPTARG}"
1053             REPO_ARGS+=(-k "$REPOSITORY_KEY")
1054             ;;
1055         u)
1056             REPOSITORY_BASE="${OPTARG}"
1057             REPO_ARGS+=(-u "$REPOSITORY_BASE")
1058             ;;
1059         R)
1060             RELEASE="${OPTARG}"
1061             REPO_ARGS+=(-R "$RELEASE")
1062             ;;
1063         D)
1064             OSM_DEVOPS="${OPTARG}"
1065             ;;
1066         o)
1067             INSTALL_ONLY="y"
1068             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1069             [ "${OPTARG}" == "ng-sa" ] && INSTALL_NGSA="y" && continue
1070             ;;
1071         O)
1072             INSTALL_TO_OPENSTACK="y"
1073             if [ -n "${OPTARG}" ]; then
1074                 OPENSTACK_OPENRC_FILE_OR_CLOUD="${OPTARG}"
1075             else
1076                 echo -e "Invalid argument for -O : ' $OPTARG'\n" >&2
1077                 usage && exit 1
1078             fi
1079             ;;
1080         f)
1081             OPENSTACK_SSH_KEY_FILE="${OPTARG}"
1082             ;;
1083         F)
1084             OPENSTACK_USERDATA_FILE="${OPTARG}"
1085             ;;
1086         N)
1087             OPENSTACK_PUBLIC_NET_NAME="${OPTARG}"
1088             ;;
1089         m)
1090             [ "${OPTARG}" == "NG-UI" ] && TO_REBUILD="$TO_REBUILD NG-UI" && continue
1091             [ "${OPTARG}" == "NBI" ] && TO_REBUILD="$TO_REBUILD NBI" && continue
1092             [ "${OPTARG}" == "LCM" ] && TO_REBUILD="$TO_REBUILD LCM" && continue
1093             [ "${OPTARG}" == "RO" ] && TO_REBUILD="$TO_REBUILD RO" && continue
1094             [ "${OPTARG}" == "MON" ] && TO_REBUILD="$TO_REBUILD MON" && continue
1095             [ "${OPTARG}" == "POL" ] && TO_REBUILD="$TO_REBUILD POL" && continue
1096             [ "${OPTARG}" == "PLA" ] && TO_REBUILD="$TO_REBUILD PLA" && continue
1097             [ "${OPTARG}" == "osmclient" ] && TO_REBUILD="$TO_REBUILD osmclient" && continue
1098             [ "${OPTARG}" == "KAFKA" ] && TO_REBUILD="$TO_REBUILD KAFKA" && continue
1099             [ "${OPTARG}" == "MONGO" ] && TO_REBUILD="$TO_REBUILD MONGO" && continue
1100             [ "${OPTARG}" == "PROMETHEUS" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS" && continue
1101             [ "${OPTARG}" == "PROMETHEUS-CADVISOR" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS-CADVISOR" && continue
1102             [ "${OPTARG}" == "KEYSTONE-DB" ] && TO_REBUILD="$TO_REBUILD KEYSTONE-DB" && continue
1103             [ "${OPTARG}" == "GRAFANA" ] && TO_REBUILD="$TO_REBUILD GRAFANA" && continue
1104             [ "${OPTARG}" == "NONE" ] && TO_REBUILD="$TO_REBUILD NONE" && continue
1105             ;;
1106         H)
1107             OSM_VCA_HOST="${OPTARG}"
1108             ;;
1109         S)
1110             OSM_VCA_SECRET="${OPTARG}"
1111             ;;
1112         s)
1113             OSM_STACK_NAME="${OPTARG}" && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
1114             ;;
1115         t)
1116             OSM_DOCKER_TAG="${OPTARG}"
1117             REPO_ARGS+=(-t "$OSM_DOCKER_TAG")
1118             ;;
1119         U)
1120             DOCKER_USER="${OPTARG}"
1121             ;;
1122         P)
1123             OSM_VCA_PUBKEY=$(cat ${OPTARG})
1124             ;;
1125         A)
1126             OSM_VCA_APIPROXY="${OPTARG}"
1127             ;;
1128         l)
1129             LXD_CLOUD_FILE="${OPTARG}"
1130             ;;
1131         L)
1132             LXD_CRED_FILE="${OPTARG}"
1133             ;;
1134         K)
1135             CONTROLLER_NAME="${OPTARG}"
1136             ;;
1137         d)
1138             DOCKER_REGISTRY_URL="${OPTARG}"
1139             ;;
1140         p)
1141             DOCKER_PROXY_URL="${OPTARG}"
1142             ;;
1143         T)
1144             MODULE_DOCKER_TAG="${OPTARG}"
1145             ;;
1146         -)
1147             [ "${OPTARG}" == "help" ] && usage && exit 0
1148             [ "${OPTARG}" == "source" ] && INSTALL_FROM_SOURCE="y" && PULL_IMAGES="" && continue
1149             [ "${OPTARG}" == "debug" ] && DEBUG_INSTALL="--debug" && continue
1150             [ "${OPTARG}" == "develop" ] && DEVELOP="y" && continue
1151             [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue
1152             [ "${OPTARG}" == "update" ] && UPDATE="y" && continue
1153             [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE="y" && continue
1154             [ "${OPTARG}" == "test" ] && TEST_INSTALLER="y" && continue
1155             [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD="y" && continue
1156             [ "${OPTARG}" == "nolxd" ] && INSTALL_NOLXD="y" && continue
1157             [ "${OPTARG}" == "nodocker" ] && INSTALL_NODOCKER="y" && continue
1158             [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue
1159             [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS="y" && continue
1160             [ "${OPTARG}" == "nojuju" ] && INSTALL_NOJUJU="--nojuju" && continue
1161             [ "${OPTARG}" == "nodockerbuild" ] && DOCKER_NOBUILD="y" && continue
1162             [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue
1163             [ "${OPTARG}" == "pullimages" ] && continue
1164             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1165             [ "${OPTARG}" == "charmed" ] && CHARMED="y" && OSM_INSTALLATION_TYPE="Charmed" && continue
1166             [ "${OPTARG}" == "bundle" ] && continue
1167             [ "${OPTARG}" == "k8s" ] && continue
1168             [ "${OPTARG}" == "lxd" ] && continue
1169             [ "${OPTARG}" == "lxd-cred" ] && continue
1170             [ "${OPTARG}" == "microstack" ] && continue
1171             [ "${OPTARG}" == "overlay" ] && continue
1172             [ "${OPTARG}" == "only-vca" ] && continue
1173             [ "${OPTARG}" == "small-profile" ] && continue
1174             [ "${OPTARG}" == "vca" ] && continue
1175             [ "${OPTARG}" == "ha" ] && continue
1176             [ "${OPTARG}" == "tag" ] && continue
1177             [ "${OPTARG}" == "registry" ] && continue
1178             [ "${OPTARG}" == "pla" ] && INSTALL_PLA="y" && continue
1179             [ "${OPTARG}" == "ng-sa" ] && INSTALL_NGSA="y" && continue
1180             [ "${OPTARG}" == "volume" ] && OPENSTACK_ATTACH_VOLUME="true" && continue
1181             [ "${OPTARG}" == "nocachelxdimages" ] && continue
1182             [ "${OPTARG}" == "cachelxdimages" ] && INSTALL_CACHELXDIMAGES="--cachelxdimages" && continue
1183             echo -e "Invalid option: '--$OPTARG'\n" >&2
1184             usage && exit 1
1185             ;;
1186         :)
1187             echo "Option -$OPTARG requires an argument" >&2
1188             usage && exit 1
1189             ;;
1190         \?)
1191             echo -e "Invalid option: '-$OPTARG'\n" >&2
1192             usage && exit 1
1193             ;;
1194         h)
1195             usage && exit 0
1196             ;;
1197         y)
1198             ASSUME_YES="y"
1199             ;;
1200         *)
1201             usage && exit 1
1202             ;;
1203     esac
1204 done
1205
1206 source $OSM_DEVOPS/common/all_funcs
1207
1208 [ -z "${DEBUG_INSTALL}" ] || DEBUG Debug is on
1209 [ -n "$SHOWOPTS" ] && dump_vars && exit 0
1210
1211 # Uninstall if "--uninstall"
1212 if [ -n "$UNINSTALL" ]; then
1213     if [ -n "$CHARMED" ]; then
1214         ${OSM_DEVOPS}/installers/charmed_uninstall.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D $OSM_DEVOPS -t $DOCKER_TAG "$@" || \
1215         FATAL_TRACK charmed_uninstall "charmed_uninstall.sh failed"
1216     else
1217         ${OSM_DEVOPS}/installers/uninstall_osm.sh "$@" || \
1218         FATAL_TRACK community_uninstall "uninstall_osm.sh failed"
1219     fi
1220     echo -e "\nDONE"
1221     exit 0
1222 fi
1223
1224 # Charmed installation
1225 if [ -n "$CHARMED" ]; then
1226     export OSM_TRACK_INSTALLATION_ID="$(date +%s)-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 16)"
1227     track start release $RELEASE none none docker_tag $OSM_DOCKER_TAG none none installation_type $OSM_INSTALLATION_TYPE none none
1228     ${OSM_DEVOPS}/installers/charmed_install.sh --tag $OSM_DOCKER_TAG "$@" || \
1229     FATAL_TRACK charmed_install "charmed_install.sh failed"
1230     wget -q -O- https://osm-download.etsi.org/ftp/osm-13.0-thirteen/README2.txt &> /dev/null
1231     track end installation_type $OSM_INSTALLATION_TYPE
1232     echo -e "\nDONE"
1233     exit 0
1234 fi
1235
1236 # Installation to Openstack
1237 if [ -n "$INSTALL_TO_OPENSTACK" ]; then
1238     install_to_openstack $OPENSTACK_OPENRC_FILE_OR_CLOUD $OPENSTACK_PUBLIC_NET_NAME $OPENSTACK_ATTACH_VOLUME
1239     echo -e "\nDONE"
1240     exit 0
1241 fi
1242
1243 # Community_installer
1244
1245 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" != " NONE" ] && echo $TO_REBUILD | grep -q NONE && FATAL "Incompatible option: -m NONE cannot be used with other -m options"
1246 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" == " PLA" ] && [ -z "$INSTALL_PLA" ] && FATAL "Incompatible option: -m PLA cannot be used without --pla option"
1247 # if develop, we force master
1248 [ -z "$COMMIT_ID" ] && [ -n "$DEVELOP" ] && COMMIT_ID="master"
1249 OSM_K8S_WORK_DIR="$OSM_DOCKER_WORK_DIR/osm_pods" && OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1250 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
1251 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_NGSA" ] && install_osm_ngsa_service
1252 [ -n "$INSTALL_ONLY" ] && echo -e "\nDONE" && exit 0
1253
1254 #Installation starts here
1255 wget -q -O- https://osm-download.etsi.org/ftp/osm-13.0-thirteen/README.txt &> /dev/null
1256 export OSM_TRACK_INSTALLATION_ID="$(date +%s)-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 16)"
1257 install_osm
1258 echo -e "\nDONE"
1259 exit 0