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