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