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 prereq apt_proxy_configured_ok
 611     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 612 }
 613
 614 function install_osm() {
 615     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 616     track checks checkingroot_ok
 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 checks noroot_ok
 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 checks proceed_ok
 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 prereq prereqok_ok
 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} || FATAL_TRACK docker_ce "install_docker_ce.sh failed"
 663     fi
 664
 665     track docker_ce docker_ce_ok
 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     FATAL_TRACK k8scluster "install_kubeadm_cluster.sh failed"
 674     track k8scluster k8scluster_ok
 675
 676     JUJU_OPTS="-D ${OSM_DEVOPS} -s ${OSM_STACK_NAME} -i ${DEFAULT_IP} ${DEBUG_INSTALL} ${INSTALL_NOJUJU} ${INSTALL_CACHELXDIMAGES}"
 677     [ -n "${OSM_VCA_HOST}" ] && JUJU_OPTS="$JUJU_OPTS -H ${OSM_VCA_HOST}"
 678     [ -n "${LXD_CLOUD_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -l ${LXD_CLOUD_FILE}"
 679     [ -n "${LXD_CRED_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -L ${LXD_CRED_FILE}"
 680     [ -n "${CONTROLLER_NAME}" ] && JUJU_OPTS="$JUJU_OPTS -K ${CONTROLLER_NAME}"
 681     $OSM_DEVOPS/installers/install_juju.sh ${JUJU_OPTS} || FATAL_TRACK juju "install_juju.sh failed"
 682     set_vca_variables
 683     track juju juju_ok
 684
 685     if [ -z "$OSM_DATABASE_COMMONKEY" ]; then
 686         OSM_DATABASE_COMMONKEY=$(generate_secret)
 687         [ -z "OSM_DATABASE_COMMONKEY" ] && FATAL "Cannot generate common db secret"
 688     fi
 689
 690     # Deploy OSM services
 691     [ -z "$DOCKER_NOBUILD" ] && generate_docker_images
 692     track docker_images docker_images_ok
 693
 694     generate_k8s_manifest_files
 695     track osm_files manifest_files_ok
 696     generate_docker_env_files
 697     track osm_files env_files_ok
 698
 699     deploy_charmed_services
 700     track deploy_osm deploy_charmed_services_ok
 701     kube_secrets
 702     track deploy_osm kube_secrets_ok
 703     update_manifest_files
 704     track deploy_osm update_manifest_files_ok
 705     namespace_vol
 706     track deploy_osm namespace_vol_ok
 707     deploy_osm_services
 708     track deploy_osm deploy_osm_services_k8s_ok
 709     if [ -n "$INSTALL_PLA"]; then
 710         # optional PLA install
 711         deploy_osm_pla_service
 712         track deploy_osm deploy_osm_pla_ok
 713     fi
 714     if [ -n "$INSTALL_K8S_MONITOR" ]; then
 715         # install OSM MONITORING
 716         install_k8s_monitoring
 717         track deploy_osm install_k8s_monitoring_ok
 718     fi
 719
 720     [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
 721     track osmclient osmclient_ok
 722
 723     echo -e "Checking OSM health state..."
 724     $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_STACK_NAME} -k || \
 725     echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
 726     echo -e "Check OSM status with: kubectl -n ${OSM_STACK_NAME} get all" && \
 727     track healthchecks osm_unhealthy didnotconverge
 728     track healthchecks after_healthcheck_ok
 729
 730     add_local_k8scluster
 731     track final_ops add_local_k8scluster_ok
 732
 733     wget -q -O- https://osm-download.etsi.org/ftp/osm-11.0-eleven/README2.txt &> /dev/null
 734     track end
 735     sudo find /etc/osm
 736     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 737     return 0
 738 }
 739
 740 function install_to_openstack() {
 741     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 742
 743     if [ -z "$2" ]; then
 744         FATAL "OpenStack installer requires a valid external network name"
 745     fi
 746
 747     # Install Pip for Python3
 748     sudo apt install -y python3-pip python3-venv
 749     sudo -H LC_ALL=C python3 -m pip install -U pip
 750
 751     # Create a venv to avoid conflicts with the host installation
 752     python3 -m venv $OPENSTACK_PYTHON_VENV
 753
 754     source $OPENSTACK_PYTHON_VENV/bin/activate
 755
 756     # Install Ansible, OpenStack client and SDK, latest openstack version supported is Train
 757     python -m pip install -U wheel
 758     python -m pip install -U "python-openstackclient<=4.0.2" "openstacksdk>=0.12.0,<=0.36.2" "ansible>=2.10,<2.11"
 759
 760     # Install the Openstack cloud module (ansible>=2.10)
 761     ansible-galaxy collection install openstack.cloud
 762
 763     export ANSIBLE_CONFIG="$OSM_DEVOPS/installers/openstack/ansible.cfg"
 764
 765     OSM_INSTALLER_ARGS="${REPO_ARGS[@]}"
 766
 767     ANSIBLE_VARS="external_network_name=$2 setup_volume=$3 server_name=$OPENSTACK_VM_NAME"
 768
 769     if [ -n "$OPENSTACK_SSH_KEY_FILE" ]; then
 770         ANSIBLE_VARS+=" key_file=$OPENSTACK_SSH_KEY_FILE"
 771     fi
 772
 773     if [ -n "$OPENSTACK_USERDATA_FILE" ]; then
 774         ANSIBLE_VARS+=" userdata_file=$OPENSTACK_USERDATA_FILE"
 775     fi
 776
 777     # Execute the Ansible playbook based on openrc or clouds.yaml
 778     if [ -e "$1" ]; then
 779         . $1
 780         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 781         $OSM_DEVOPS/installers/openstack/site.yml
 782     else
 783         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 784         -e cloud_name=$1 $OSM_DEVOPS/installers/openstack/site.yml
 785     fi
 786
 787     # Exit from venv
 788     deactivate
 789
 790     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 791     return 0
 792 }
 793
 794 function install_k8s_monitoring() {
 795     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 796     # install OSM monitoring
 797     sudo chmod +x $OSM_DEVOPS/installers/k8s/*.sh
 798     sudo $OSM_DEVOPS/installers/k8s/install_osm_k8s_monitoring.sh || FATAL_TRACK install_k8s_monitoring "k8s/install_osm_k8s_monitoring.sh failed"
 799     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 800 }
 801
 802 function dump_vars(){
 803     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 804     echo "APT_PROXY_URL=$APT_PROXY_URL"
 805     echo "DEVELOP=$DEVELOP"
 806     echo "DEBUG_INSTALL=$DEBUG_INSTALL"
 807     echo "DOCKER_NOBUILD=$DOCKER_NOBUILD"
 808     echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL"
 809     echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL"
 810     echo "DOCKER_USER=$DOCKER_USER"
 811     echo "INSTALL_CACHELXDIMAGES=$INSTALL_CACHELXDIMAGES"
 812     echo "INSTALL_FROM_SOURCE=$INSTALL_FROM_SOURCE"
 813     echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
 814     echo "INSTALL_LIGHTWEIGHT=$INSTALL_LIGHTWEIGHT"
 815     echo "INSTALL_LXD=$INSTALL_LXD"
 816     echo "INSTALL_NODOCKER=$INSTALL_NODOCKER"
 817     echo "INSTALL_NOJUJU=$INSTALL_NOJUJU"
 818     echo "INSTALL_NOLXD=$INSTALL_NOLXD"
 819     echo "INSTALL_ONLY=$INSTALL_ONLY"
 820     echo "INSTALL_PLA=$INSTALL_PLA"
 821     echo "INSTALL_TO_OPENSTACK=$INSTALL_TO_OPENSTACK"
 822     echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
 823     echo "NO_HOST_PORTS=$NO_HOST_PORTS"
 824     echo "OPENSTACK_PUBLIC_NET_NAME=$OPENSTACK_PUBLIC_NET_NAME"
 825     echo "OPENSTACK_OPENRC_FILE_OR_CLOUD=$OPENSTACK_OPENRC_FILE_OR_CLOUD"
 826     echo "OPENSTACK_ATTACH_VOLUME=$OPENSTACK_ATTACH_VOLUME"
 827     echo "OPENSTACK_SSH_KEY_FILE"="$OPENSTACK_SSH_KEY_FILE"
 828     echo "OPENSTACK_USERDATA_FILE"="$OPENSTACK_USERDATA_FILE"
 829     echo "OPENSTACK_VM_NAME"="$OPENSTACK_VM_NAME"
 830     echo "OSM_DEVOPS=$OSM_DEVOPS"
 831     echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
 832     echo "OSM_STACK_NAME=$OSM_STACK_NAME"
 833     echo "OSM_VCA_HOST=$OSM_VCA_HOST"
 834     echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
 835     echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
 836     echo "OSM_WORK_DIR=$OSM_WORK_DIR"
 837     echo "PULL_IMAGES=$PULL_IMAGES"
 838     echo "RECONFIGURE=$RECONFIGURE"
 839     echo "RELEASE=$RELEASE"
 840     echo "REPOSITORY=$REPOSITORY"
 841     echo "REPOSITORY_BASE=$REPOSITORY_BASE"
 842     echo "REPOSITORY_KEY=$REPOSITORY_KEY"
 843     echo "SHOWOPTS=$SHOWOPTS"
 844     echo "TEST_INSTALLER=$TEST_INSTALLER"
 845     echo "TO_REBUILD=$TO_REBUILD"
 846     echo "UNINSTALL=$UNINSTALL"
 847     echo "UPDATE=$UPDATE"
 848     echo "Install from specific refspec (-b): $COMMIT_ID"
 849     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 850 }
 851
 852 function parse_docker_registry_url() {
 853     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 854     DOCKER_REGISTRY_USER=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}')
 855     DOCKER_REGISTRY_PASSWORD=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}')
 856     DOCKER_REGISTRY_URL=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); print a[2]}')
 857     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 858 }
 859
 860 LXD_VERSION=4.0
 861 JUJU_VERSION=2.9
 862 JUJU_AGENT_VERSION=2.9.17
 863 UNINSTALL=""
 864 DEVELOP=""
 865 UPDATE=""
 866 RECONFIGURE=""
 867 TEST_INSTALLER=""
 868 INSTALL_LXD=""
 869 SHOWOPTS=""
 870 COMMIT_ID=""
 871 ASSUME_YES=""
 872 APT_PROXY_URL=""
 873 INSTALL_FROM_SOURCE=""
 874 DEBUG_INSTALL=""
 875 RELEASE="ReleaseTEN"
 876 REPOSITORY="stable"
 877 INSTALL_VIMEMU=""
 878 INSTALL_PLA=""
 879 LXD_REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/lxd"
 880 LXD_REPOSITORY_PATH=""
 881 INSTALL_LIGHTWEIGHT="y"
 882 INSTALL_TO_OPENSTACK=""
 883 OPENSTACK_OPENRC_FILE_OR_CLOUD=""
 884 OPENSTACK_PUBLIC_NET_NAME=""
 885 OPENSTACK_ATTACH_VOLUME="false"
 886 OPENSTACK_SSH_KEY_FILE=""
 887 OPENSTACK_USERDATA_FILE=""
 888 OPENSTACK_VM_NAME="server-osm"
 889 OPENSTACK_PYTHON_VENV="$HOME/.virtual-envs/osm"
 890 INSTALL_ONLY=""
 891 TO_REBUILD=""
 892 INSTALL_NOLXD=""
 893 INSTALL_NODOCKER=""
 894 INSTALL_NOJUJU=""
 895 INSTALL_K8S_MONITOR=""
 896 INSTALL_NOHOSTCLIENT=""
 897 INSTALL_CACHELXDIMAGES=""
 898 OSM_DEVOPS=
 899 OSM_VCA_HOST=
 900 OSM_VCA_SECRET=
 901 OSM_VCA_PUBKEY=
 902 OSM_VCA_CLOUDNAME="localhost"
 903 OSM_VCA_K8S_CLOUDNAME="k8scloud"
 904 OSM_STACK_NAME=osm
 905 NO_HOST_PORTS=""
 906 DOCKER_NOBUILD=""
 907 REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
 908 REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian"
 909 OSM_WORK_DIR="/etc/osm"
 910 OSM_DOCKER_WORK_DIR="/etc/osm/docker"
 911 OSM_K8S_WORK_DIR="${OSM_DOCKER_WORK_DIR}/osm_pods"
 912 OSM_HOST_VOL="/var/lib/osm"
 913 OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
 914 OSM_DOCKER_TAG=latest
 915 DOCKER_USER=opensourcemano
 916 PULL_IMAGES="y"
 917 KAFKA_TAG=2.11-1.0.2
 918 PROMETHEUS_TAG=v2.4.3
 919 GRAFANA_TAG=latest
 920 PROMETHEUS_NODE_EXPORTER_TAG=0.18.1
 921 PROMETHEUS_CADVISOR_TAG=latest
 922 KEYSTONEDB_TAG=10
 923 OSM_DATABASE_COMMONKEY=
 924 ELASTIC_VERSION=6.4.2
 925 ELASTIC_CURATOR_VERSION=5.5.4
 926 POD_NETWORK_CIDR=10.244.0.0/16
 927 K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
 928 RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
 929 DOCKER_REGISTRY_URL=
 930 DOCKER_PROXY_URL=
 931 MODULE_DOCKER_TAG=
 932 OSM_INSTALLATION_TYPE="Default"
 933
 934 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
 935     case "${o}" in
 936         a)
 937             APT_PROXY_URL=${OPTARG}
 938             ;;
 939         b)
 940             COMMIT_ID=${OPTARG}
 941             PULL_IMAGES=""
 942             ;;
 943         r)
 944             REPOSITORY="${OPTARG}"
 945             REPO_ARGS+=(-r "$REPOSITORY")
 946             ;;
 947         k)
 948             REPOSITORY_KEY="${OPTARG}"
 949             REPO_ARGS+=(-k "$REPOSITORY_KEY")
 950             ;;
 951         u)
 952             REPOSITORY_BASE="${OPTARG}"
 953             REPO_ARGS+=(-u "$REPOSITORY_BASE")
 954             ;;
 955         R)
 956             RELEASE="${OPTARG}"
 957             REPO_ARGS+=(-R "$RELEASE")
 958             ;;
 959         D)
 960             OSM_DEVOPS="${OPTARG}"
 961             ;;
 962         o)
 963             INSTALL_ONLY="y"
 964             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
 965             ;;
 966         O)
 967             INSTALL_TO_OPENSTACK="y"
 968             if [ -n "${OPTARG}" ]; then
 969                 OPENSTACK_OPENRC_FILE_OR_CLOUD="${OPTARG}"
 970             else
 971                 echo -e "Invalid argument for -O : ' $OPTARG'\n" >&2
 972                 usage && exit 1
 973             fi
 974             ;;
 975         f)
 976             OPENSTACK_SSH_KEY_FILE="${OPTARG}"
 977             ;;
 978         F)
 979             OPENSTACK_USERDATA_FILE="${OPTARG}"
 980             ;;
 981         N)
 982             OPENSTACK_PUBLIC_NET_NAME="${OPTARG}"
 983             ;;
 984         m)
 985             [ "${OPTARG}" == "NG-UI" ] && TO_REBUILD="$TO_REBUILD NG-UI" && continue
 986             [ "${OPTARG}" == "NBI" ] && TO_REBUILD="$TO_REBUILD NBI" && continue
 987             [ "${OPTARG}" == "LCM" ] && TO_REBUILD="$TO_REBUILD LCM" && continue
 988             [ "${OPTARG}" == "RO" ] && TO_REBUILD="$TO_REBUILD RO" && continue
 989             [ "${OPTARG}" == "MON" ] && TO_REBUILD="$TO_REBUILD MON" && continue
 990             [ "${OPTARG}" == "POL" ] && TO_REBUILD="$TO_REBUILD POL" && continue
 991             [ "${OPTARG}" == "PLA" ] && TO_REBUILD="$TO_REBUILD PLA" && continue
 992             [ "${OPTARG}" == "osmclient" ] && TO_REBUILD="$TO_REBUILD osmclient" && continue
 993             [ "${OPTARG}" == "KAFKA" ] && TO_REBUILD="$TO_REBUILD KAFKA" && continue
 994             [ "${OPTARG}" == "MONGO" ] && TO_REBUILD="$TO_REBUILD MONGO" && continue
 995             [ "${OPTARG}" == "PROMETHEUS" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS" && continue
 996             [ "${OPTARG}" == "PROMETHEUS-CADVISOR" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS-CADVISOR" && continue
 997             [ "${OPTARG}" == "KEYSTONE-DB" ] && TO_REBUILD="$TO_REBUILD KEYSTONE-DB" && continue
 998             [ "${OPTARG}" == "GRAFANA" ] && TO_REBUILD="$TO_REBUILD GRAFANA" && continue
 999             [ "${OPTARG}" == "NONE" ] && TO_REBUILD="$TO_REBUILD NONE" && continue
1000             ;;
1001         H)
1002             OSM_VCA_HOST="${OPTARG}"
1003             ;;
1004         S)
1005             OSM_VCA_SECRET="${OPTARG}"
1006             ;;
1007         s)
1008             OSM_STACK_NAME="${OPTARG}" && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
1009             ;;
1010         t)
1011             OSM_DOCKER_TAG="${OPTARG}"
1012             REPO_ARGS+=(-t "$OSM_DOCKER_TAG")
1013             ;;
1014         U)
1015             DOCKER_USER="${OPTARG}"
1016             ;;
1017         P)
1018             OSM_VCA_PUBKEY=$(cat ${OPTARG})
1019             ;;
1020         A)
1021             OSM_VCA_APIPROXY="${OPTARG}"
1022             ;;
1023         l)
1024             LXD_CLOUD_FILE="${OPTARG}"
1025             ;;
1026         L)
1027             LXD_CRED_FILE="${OPTARG}"
1028             ;;
1029         K)
1030             CONTROLLER_NAME="${OPTARG}"
1031             ;;
1032         d)
1033             DOCKER_REGISTRY_URL="${OPTARG}"
1034             ;;
1035         p)
1036             DOCKER_PROXY_URL="${OPTARG}"
1037             ;;
1038         T)
1039             MODULE_DOCKER_TAG="${OPTARG}"
1040             ;;
1041         -)
1042             [ "${OPTARG}" == "help" ] && usage && exit 0
1043             [ "${OPTARG}" == "source" ] && INSTALL_FROM_SOURCE="y" && PULL_IMAGES="" && continue
1044             [ "${OPTARG}" == "debug" ] && DEBUG_INSTALL="--debug" && continue
1045             [ "${OPTARG}" == "develop" ] && DEVELOP="y" && continue
1046             [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue
1047             [ "${OPTARG}" == "update" ] && UPDATE="y" && continue
1048             [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE="y" && continue
1049             [ "${OPTARG}" == "test" ] && TEST_INSTALLER="y" && continue
1050             [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD="y" && continue
1051             [ "${OPTARG}" == "nolxd" ] && INSTALL_NOLXD="y" && continue
1052             [ "${OPTARG}" == "nodocker" ] && INSTALL_NODOCKER="y" && continue
1053             [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue
1054             [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS="y" && continue
1055             [ "${OPTARG}" == "nojuju" ] && INSTALL_NOJUJU="--nojuju" && continue
1056             [ "${OPTARG}" == "nodockerbuild" ] && DOCKER_NOBUILD="y" && continue
1057             [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue
1058             [ "${OPTARG}" == "pullimages" ] && continue
1059             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1060             [ "${OPTARG}" == "charmed" ] && CHARMED="y" && OSM_INSTALLATION_TYPE="Charmed" && continue
1061             [ "${OPTARG}" == "bundle" ] && continue
1062             [ "${OPTARG}" == "k8s" ] && continue
1063             [ "${OPTARG}" == "lxd" ] && continue
1064             [ "${OPTARG}" == "lxd-cred" ] && continue
1065             [ "${OPTARG}" == "microstack" ] && continue
1066             [ "${OPTARG}" == "overlay" ] && continue
1067             [ "${OPTARG}" == "only-vca" ] && continue
1068             [ "${OPTARG}" == "vca" ] && continue
1069             [ "${OPTARG}" == "ha" ] && continue
1070             [ "${OPTARG}" == "tag" ] && continue
1071             [ "${OPTARG}" == "registry" ] && continue
1072             [ "${OPTARG}" == "pla" ] && INSTALL_PLA="y" && continue
1073             [ "${OPTARG}" == "volume" ] && OPENSTACK_ATTACH_VOLUME="true" && continue
1074             [ "${OPTARG}" == "nocachelxdimages" ] && continue
1075             [ "${OPTARG}" == "cachelxdimages" ] && INSTALL_CACHELXDIMAGES="--cachelxdimages" && continue
1076             echo -e "Invalid option: '--$OPTARG'\n" >&2
1077             usage && exit 1
1078             ;;
1079         :)
1080             echo "Option -$OPTARG requires an argument" >&2
1081             usage && exit 1
1082             ;;
1083         \?)
1084             echo -e "Invalid option: '-$OPTARG'\n" >&2
1085             usage && exit 1
1086             ;;
1087         h)
1088             usage && exit 0
1089             ;;
1090         y)
1091             ASSUME_YES="y"
1092             ;;
1093         *)
1094             usage && exit 1
1095             ;;
1096     esac
1097 done
1098
1099 source $OSM_DEVOPS/common/all_funcs
1100
1101 [ -z "${DEBUG_INSTALL}" ] || DEBUG Debug is on
1102 [ -n "$SHOWOPTS" ] && dump_vars && exit 0
1103
1104 # Uninstall if "--uninstall"
1105 if [ -n "$UNINSTALL" ]; then
1106     if [ -n "$CHARMED" ]; then
1107         track start release $RELEASE none none docker_tag $OSM_DOCKER_TAG none none installation_type $OSM_INSTALLATION_TYPE none none
1108         ${OSM_DEVOPS}/installers/charmed_uninstall.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D $OSM_DEVOPS -t $DOCKER_TAG "$@" || \
1109         FATAL_TRACK charmed_uninstall "charmed_uninstall.sh failed"
1110     else
1111         ${OSM_DEVOPS}/installers/uninstall_osm.sh "$@" || \
1112         FATAL_TRACK community_uninstall "uninstall_osm.sh failed"
1113     fi
1114     echo -e "\nDONE"
1115     exit 0
1116 fi
1117
1118 # Charmed installation
1119 if [ -n "$CHARMED" ]; then
1120     ${OSM_DEVOPS}/installers/charmed_install.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D $OSM_DEVOPS -t $DOCKER_TAG "$@" || \
1121     FATAL_TRACK charmed_install "charmed_install.sh failed"
1122     echo -e "\nDONE"
1123     exit 0
1124 fi
1125
1126 # Installation to Openstack
1127 if [ -n "$INSTALL_TO_OPENSTACK" ]; then
1128     install_to_openstack $OPENSTACK_OPENRC_FILE_OR_CLOUD $OPENSTACK_PUBLIC_NET_NAME $OPENSTACK_ATTACH_VOLUME
1129     echo -e "\nDONE"
1130     exit 0
1131 fi
1132
1133 # Community_installer
1134 [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url
1135 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" != " NONE" ] && echo $TO_REBUILD | grep -q NONE && FATAL "Incompatible option: -m NONE cannot be used with other -m options"
1136 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" == " PLA" ] && [ -z "$INSTALL_PLA" ] && FATAL "Incompatible option: -m PLA cannot be used without --pla option"
1137
1138 # if develop, we force master
1139 [ -z "$COMMIT_ID" ] && [ -n "$DEVELOP" ] && COMMIT_ID="master"
1140
1141 need_packages="git wget curl tar"
1142
1143 echo -e "Checking required packages: $need_packages"
1144 dpkg -l $need_packages &>/dev/null \
1145   || ! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1146   || sudo apt-get update \
1147   || FATAL "failed to run apt-get update"
1148 dpkg -l $need_packages &>/dev/null \
1149   || ! echo -e "Installing $need_packages requires root privileges." \
1150   || sudo apt-get install -y $need_packages \
1151   || FATAL "failed to install $need_packages"
1152 sudo snap install jq
1153 if [ -z "$OSM_DEVOPS" ]; then
1154     if [ -n "$TEST_INSTALLER" ]; then
1155         echo -e "\nUsing local devops repo for OSM installation"
1156         OSM_DEVOPS="$(dirname $(realpath $(dirname $0)))"
1157     else
1158         echo -e "\nCreating temporary dir for OSM installation"
1159         OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")"
1160         trap 'rm -rf "$OSM_DEVOPS"' EXIT
1161
1162         git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS
1163
1164         if [ -z "$COMMIT_ID" ]; then
1165             echo -e "\nGuessing the current stable release"
1166             LATEST_STABLE_DEVOPS=`git -C $OSM_DEVOPS tag -l v[0-9].* | sort -V | tail -n1`
1167             [ -z "$LATEST_STABLE_DEVOPS" ] && echo "Could not find the current latest stable release" && exit 0
1168
1169             echo "Latest tag in devops repo: $LATEST_STABLE_DEVOPS"
1170             COMMIT_ID="tags/$LATEST_STABLE_DEVOPS"
1171         else
1172             echo -e "\nDEVOPS Using commit $COMMIT_ID"
1173         fi
1174         git -C $OSM_DEVOPS checkout $COMMIT_ID
1175     fi
1176 fi
1177
1178 [ "${OSM_STACK_NAME}" == "osm" ] || OSM_DOCKER_WORK_DIR="$OSM_WORK_DIR/stack/$OSM_STACK_NAME"
1179 OSM_K8S_WORK_DIR="$OSM_DOCKER_WORK_DIR/osm_pods" && OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1180 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
1181 [ -n "$INSTALL_ONLY" ] && echo -e "\nDONE" && exit 0
1182
1183 #Installation starts here
1184 wget -q -O- https://osm-download.etsi.org/ftp/osm-11.0-eleven/README.txt &> /dev/null
1185 export OSM_TRACK_INSTALLATION_ID="$(date +%s)-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 16)"
1186
1187 track start release $RELEASE none none docker_tag $OSM_DOCKER_TAG none none installation_type $OSM_INSTALLATION_TYPE none none
1188
1189 install_osm
1190 echo -e "\nDONE"
1191 exit 0
1192