installers/full_install_osm.sh

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