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