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