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