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