installers/full_install_osm.sh

   1 #!/bin/bash
   2 #   Copyright 2016 Telefónica Investigación y Desarrollo S.A.U.
   3 #
   4 #   Licensed under the Apache License, Version 2.0 (the "License");
   5 #   you may not use this file except in compliance with the License.
   6 #   You may obtain a copy of the License at
   7 #
   8 #       http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 #   Unless required by applicable law or agreed to in writing, software
  11 #   distributed under the License is distributed on an "AS IS" BASIS,
  12 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 #   See the License for the specific language governing permissions and
  14 #   limitations under the License.
  15
  16 function usage(){
  17     echo -e "usage: $0 [OPTIONS]"
  18     echo -e "Install OSM from binaries or source code (by default, from binaries)"
  19     echo -e "  OPTIONS"
  20     echo -e "     -r <repo>:      use specified repository name for osm packages"
  21     echo -e "     -R <release>:   use specified release for osm binaries (deb packages, lxd images, ...)"
  22     echo -e "     -u <repo base>: use specified repository url for osm packages"
  23     echo -e "     -k <repo key>:  use specified repository public key url"
  24     echo -e "     -b <refspec>:   install OSM from source code using a specific branch (master, v2.0, ...) or tag"
  25     echo -e "                     -b master          (main dev branch)"
  26     echo -e "                     -b v2.0            (v2.0 branch)"
  27     echo -e "                     -b tags/v1.1.0     (a specific tag)"
  28     echo -e "                     ..."
  29     echo -e "     -c <orchestrator> deploy osm services using container <orchestrator>. Valid values are <k8s> or <swarm>.  If -c is not used then osm will be deployed using default orchestrator. When used with --uninstall, osm services deployed by the orchestrator will be uninstalled"
  30     echo -e "     -n <ui> install OSM with Next Gen UI. Valid values are <lwui> or <ngui>. If -n is not specified osm will be installed with light-ui. When used with uninstall, osm along with the UI specified will be uninstalled"
  31     echo -e "     -s <stack name> or <namespace>  user defined stack name when installed using swarm or namespace when installed using k8s, default is osm"
  32     echo -e "     -H <VCA host>   use specific juju host controller IP"
  33     echo -e "     -S <VCA secret> use VCA/juju secret key"
  34     echo -e "     -P <VCA pubkey> use VCA/juju public key file"
  35     echo -e "     -C <VCA cacert> use VCA/juju CA certificate file"
  36     echo -e "     -A <VCA apiproxy> use VCA/juju API proxy"
  37     echo -e "     --vimemu:       additionally deploy the VIM emulator as a docker container"
  38     echo -e "     --elk_stack:    additionally deploy an ELK docker stack for event logging"
  39     echo -e "     --pla:          install the PLA module for placement support"
  40     echo -e "     -m <MODULE>:    install OSM but only rebuild the specified docker images (LW-UI, NBI, LCM, RO, MON, POL, KAFKA, MONGO, PROMETHEUS, PROMETHEUS-CADVISOR, KEYSTONE-DB, PLA, NONE)"
  41     echo -e "     -o <ADDON>:     ONLY (un)installs one of the addons (vimemu, elk_stack, k8s_monitor)"
  42     echo -e "     -D <devops path> use local devops installation path"
  43     echo -e "     -w <work dir>   Location to store runtime installation"
  44     echo -e "     -t <docker tag> specify osm docker tag (default is latest)"
  45     echo -e "     -l:             LXD cloud yaml file"
  46     echo -e "     -L:             LXD credentials yaml file"
  47     echo -e "     -K:             Specifies the name of the controller to use - The controller must be already bootstrapped"
  48     echo -e "     --nolxd:        do not install and configure LXD, allowing unattended installations (assumes LXD is already installed and confifured)"
  49     echo -e "     --nodocker:     do not install docker, do not initialize a swarm (assumes docker is already installed and a swarm has been initialized)"
  50     echo -e "     --nojuju:       do not juju, assumes already installed"
  51     echo -e "     --nodockerbuild:do not build docker images (use existing locally cached images)"
  52     echo -e "     --nohostports:  do not expose docker ports to host (useful for creating multiple instances of osm on the same host)"
  53     echo -e "     --nohostclient: do not install the osmclient"
  54     echo -e "     --uninstall:    uninstall OSM: remove the containers and delete NAT rules"
  55     echo -e "     --source:       install OSM from source code using the latest stable tag"
  56     echo -e "     --develop:      (deprecated, use '-b master') install OSM from source code using the master branch"
  57     echo -e "     --pullimages:   pull/run osm images from docker.io/opensourcemano"
  58     echo -e "     --k8s_monitor:  install the OSM kubernetes monitoring with prometheus and grafana"
  59 #    echo -e "     --reconfigure:  reconfigure the modules (DO NOT change NAT rules)"
  60 #    echo -e "     --update:       update to the latest stable release or to the latest commit if using a specific branch"
  61     echo -e "     --showopts:     print chosen options and exit (only for debugging)"
  62     echo -e "     -y:             do not prompt for confirmation, assumes yes"
  63     echo -e "     -h / --help:    print this help"
  64     echo -e "     --charmed:                       install OSM with charms"
  65     echo -e "     --bundle <bundle path>:          Specify with which bundle to deploy OSM with charms (--charmed option)"
  66     echo -e "     --kubeconfig <kubeconfig path>:  Specify with which kubernetes to deploy OSM with charms (--charmed option)"
  67     echo -e "     --controller <name>:             Specifies the name of the controller to use - The controller must be already bootstrapped (--charmed option)"
  68     echo -e "     --lxd-cloud <yaml path>:         Takes a YAML file as a parameter with the LXD Cloud information (--charmed option)"
  69     echo -e "     --lxd-credentials <yaml path>:   Takes a YAML file as a parameter with the LXD Credentials information (--charmed option)"
  70     echo -e "     --microstack:                    Installs microstack as a vim. (--charmed option)"
  71     echo -e "     --tag:                           Docker image tag"
  72
  73 }
  74
  75 # takes a juju/accounts.yaml file and returns the password specific
  76 # for a controller. I wrote this using only bash tools to minimize
  77 # additions of other packages
  78 function parse_juju_password {
  79    password_file="${HOME}/.local/share/juju/accounts.yaml"
  80    local controller_name=$1
  81    local s='[[:space:]]*' w='[a-zA-Z0-9_-]*' fs=$(echo @|tr @ '\034')
  82    sed -ne "s|^\($s\):|\1|" \
  83         -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
  84         -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p" $password_file |
  85    awk -F$fs -v controller=$controller_name '{
  86       indent = length($1)/2;
  87       vname[indent] = $2;
  88       for (i in vname) {if (i > indent) {delete vname[i]}}
  89       if (length($3) > 0) {
  90          vn=""; for (i=0; i<indent; i++) {vn=(vn)(vname[i])("_")}
  91          if (match(vn,controller) && match($2,"password")) {
  92              printf("%s",$3);
  93          }
  94       }
  95    }'
  96 }
  97
  98 function generate_secret() {
  99     head /dev/urandom | tr -dc A-Za-z0-9 | head -c 32
 100 }
 101
 102 function remove_volumes() {
 103     if [ -n "$KUBERNETES" ]; then
 104         k8_volume=$1
 105         echo "Removing ${k8_volume}"
 106         $WORKDIR_SUDO rm -rf ${k8_volume}
 107     else
 108         stack=$1
 109         volumes="mongo_db mon_db osm_packages ro_db pol_db prom_db ro"
 110         for volume in $volumes; do
 111             sg docker -c "docker volume rm ${stack}_${volume}"
 112         done
 113     fi
 114 }
 115
 116 function remove_network() {
 117     stack=$1
 118     sg docker -c "docker network rm net${stack}"
 119 }
 120
 121 function remove_iptables() {
 122     stack=$1
 123     if [ -z "$OSM_VCA_HOST" ]; then
 124         OSM_VCA_HOST=`sg lxd -c "juju show-controller ${stack}"|grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
 125         [ -z "$OSM_VCA_HOST" ] && FATAL "Cannot obtain juju controller IP address"
 126     fi
 127
 128     if [ -z "$DEFAULT_IP" ]; then
 129         DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}')
 130         [ -z "$DEFAULT_IF" ] && DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
 131         [ -z "$DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0"
 132         DEFAULT_IP=`ip -o -4 a |grep ${DEFAULT_IF}|awk '{split($4,a,"/"); print a[1]}'`
 133         [ -z "$DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route"
 134     fi
 135
 136     if sudo iptables -t nat -C PREROUTING -p tcp -m tcp -d $DEFAULT_IP --dport 17070 -j DNAT --to-destination $OSM_VCA_HOST; then
 137         sudo iptables -t nat -D PREROUTING -p tcp -m tcp -d $DEFAULT_IP --dport 17070 -j DNAT --to-destination $OSM_VCA_HOST
 138         sudo netfilter-persistent save
 139     fi
 140 }
 141
 142 function remove_stack() {
 143     stack=$1
 144     if sg docker -c "docker stack ps ${stack}" ; then
 145         echo -e "\nRemoving stack ${stack}" && sg docker -c "docker stack rm ${stack}"
 146         COUNTER=0
 147         result=1
 148         while [ ${COUNTER} -lt 30 ]; do
 149             result=$(sg docker -c "docker stack ps ${stack}" | wc -l)
 150             #echo "Dockers running: $result"
 151             if [ "${result}" == "0" ]; then
 152                 break
 153             fi
 154             let COUNTER=COUNTER+1
 155             sleep 1
 156         done
 157         if [ "${result}" == "0" ]; then
 158             echo "All dockers of the stack ${stack} were removed"
 159         else
 160             FATAL "Some dockers of the stack ${stack} could not be removed. Could not clean it."
 161         fi
 162         sleep 5
 163     fi
 164 }
 165
 166 #removes osm deployments and services
 167 function remove_k8s_namespace() {
 168     kubectl delete ns $1
 169 }
 170
 171 #removes helm only if there is nothing deployed in helm
 172 function remove_helm() {
 173     if [ "$(helm ls -q)" == "" ] ; then
 174         sudo helm reset --force
 175         kubectl delete --namespace kube-system serviceaccount tiller
 176         kubectl delete clusterrolebinding tiller-cluster-rule
 177         sudo rm /usr/local/bin/helm
 178         rm -rf $HOME/.helm
 179     fi
 180 }
 181
 182 #Uninstall osmclient
 183 function uninstall_osmclient() {
 184     sudo apt-get remove --purge -y python-osmclient
 185     sudo apt-get remove --purge -y python3-osmclient
 186 }
 187
 188 #Uninstall lightweight OSM: remove dockers
 189 function uninstall_lightweight() {
 190     if [ -n "$INSTALL_ONLY" ]; then
 191         if [ -n "$INSTALL_ELK" ]; then
 192             echo -e "\nUninstalling OSM ELK stack"
 193             remove_stack osm_elk
 194             $WORKDIR_SUDO rm -rf $OSM_DOCKER_WORK_DIR/osm_elk
 195         fi
 196     else
 197         echo -e "\nUninstalling OSM"
 198         if [ -n "$KUBERNETES" ]; then
 199             if [ -n "$INSTALL_K8S_MONITOR" ]; then
 200                 # uninstall OSM MONITORING
 201                 uninstall_k8s_monitoring
 202             fi
 203             remove_k8s_namespace $OSM_STACK_NAME
 204         else
 205
 206             remove_stack $OSM_STACK_NAME
 207             remove_stack osm_elk
 208         fi
 209         echo "Now osm docker images and volumes will be deleted"
 210         newgrp docker << EONG
 211         docker image rm ${DOCKER_USER}/ro:${OSM_DOCKER_TAG}
 212         docker image rm ${DOCKER_USER}/lcm:${OSM_DOCKER_TAG}
 213         docker image rm ${DOCKER_USER}/keystone:${OSM_DOCKER_TAG}
 214         docker image rm ${DOCKER_USER}/nbi:${OSM_DOCKER_TAG}
 215         docker image rm ${DOCKER_USER}/mon:${OSM_DOCKER_TAG}
 216         docker image rm ${DOCKER_USER}/pol:${OSM_DOCKER_TAG}
 217         docker image rm ${DOCKER_USER}/pla:${OSM_DOCKER_TAG}
 218         docker image rm ${DOCKER_USER}/osmclient:${OSM_DOCKER_TAG}
 219 EONG
 220         if [ -n "$NGUI" ]; then
 221             newgrp docker << EONG
 222             docker image rm ${DOCKER_USER}/ng-ui:${OSM_DOCKER_TAG}
 223 EONG
 224         else
 225             newgrp docker << EONG
 226             docker image rm ${DOCKER_USER}/light-ui:${OSM_DOCKER_TAG}
 227 EONG
 228          fi
 229
 230         if [ -n "$KUBERNETES" ]; then
 231             OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
 232             remove_volumes $OSM_NAMESPACE_VOL
 233         else
 234             remove_volumes $OSM_STACK_NAME
 235             remove_network $OSM_STACK_NAME
 236         fi
 237         [ -z "$CONTROLLER_NAME" ] && remove_iptables $OSM_STACK_NAME
 238         echo "Removing $OSM_DOCKER_WORK_DIR"
 239         $WORKDIR_SUDO rm -rf $OSM_DOCKER_WORK_DIR
 240         [ -z "$CONTROLLER_NAME" ] && sg lxd -c "juju destroy-controller --destroy-all-models --yes $OSM_STACK_NAME"
 241     fi
 242     uninstall_osmclient
 243     echo "Some docker images will be kept in case they are used by other docker stacks"
 244     echo "To remove them, just run 'docker image prune' in a terminal"
 245     return 0
 246 }
 247
 248 #Safe unattended install of iptables-persistent
 249 function check_install_iptables_persistent(){
 250     echo -e "\nChecking required packages: iptables-persistent"
 251     if dpkg -l iptables-persistent &>/dev/null; then
 252         echo -e "    Not installed.\nInstalling iptables-persistent requires root privileges"
 253         echo iptables-persistent iptables-persistent/autosave_v4 boolean true | sudo debconf-set-selections
 254         echo iptables-persistent iptables-persistent/autosave_v6 boolean true | sudo debconf-set-selections
 255         sudo apt-get -yq install iptables-persistent
 256     fi
 257 }
 258
 259 #Configure NAT rules, based on the current IP addresses of containers
 260 function nat(){
 261     check_install_iptables_persistent
 262
 263     echo -e "\nConfiguring NAT rules"
 264     echo -e "   Required root privileges"
 265     sudo $OSM_DEVOPS/installers/nat_osm
 266 }
 267
 268 function FATAL(){
 269     echo "FATAL error: Cannot install OSM due to \"$1\""
 270     exit 1
 271 }
 272
 273 function install_lxd() {
 274     # Apply sysctl production values for optimal performance
 275     sudo cp /usr/share/osm-devops/installers/60-lxd-production.conf /etc/sysctl.d/60-lxd-production.conf
 276     sudo sysctl --system
 277
 278     # Install LXD snap
 279     sudo apt-get remove --purge -y liblxc1 lxc-common lxcfs lxd lxd-client
 280     sudo snap install lxd
 281     sudo apt-get install zfsutils-linux -y
 282
 283     # Configure LXD
 284     sudo usermod -a -G lxd `whoami`
 285     cat /usr/share/osm-devops/installers/lxd-preseed.conf | sed 's/^config: {}/config:\n  core.https_address: '$DEFAULT_IP':8443/' | sg lxd -c "lxd init --preseed"
 286     sg lxd -c "lxd waitready"
 287     DEFAULT_INTERFACE=$(ip route list|awk '$1=="default" {print $5; exit}')
 288     [ -z "$DEFAULT_INTERFACE" ] && DEFAULT_INTERFACE=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
 289     DEFAULT_MTU=$(ip addr show $DEFAULT_INTERFACE | perl -ne 'if (/mtu\s(\d+)/) {print $1;}')
 290     sg lxd -c "lxc profile device set default eth0 mtu $DEFAULT_MTU"
 291     #sudo systemctl stop lxd-bridge
 292     #sudo systemctl --system daemon-reload
 293     #sudo systemctl enable lxd-bridge
 294     #sudo systemctl start lxd-bridge
 295 }
 296
 297 function ask_user(){
 298     # ask to the user and parse a response among 'y', 'yes', 'n' or 'no'. Case insensitive
 299     # Params: $1 text to ask;   $2 Action by default, can be 'y' for yes, 'n' for no, other or empty for not allowed
 300     # Return: true(0) if user type 'yes'; false (1) if user type 'no'
 301     read -e -p "$1" USER_CONFIRMATION
 302     while true ; do
 303         [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'y' ] && return 0
 304         [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'n' ] && return 1
 305         [ "${USER_CONFIRMATION,,}" == "yes" ] || [ "${USER_CONFIRMATION,,}" == "y" ] && return 0
 306         [ "${USER_CONFIRMATION,,}" == "no" ]  || [ "${USER_CONFIRMATION,,}" == "n" ] && return 1
 307         read -e -p "Please type 'yes' or 'no': " USER_CONFIRMATION
 308     done
 309 }
 310
 311 function install_osmclient(){
 312     CLIENT_RELEASE=${RELEASE#"-R "}
 313     CLIENT_REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
 314     CLIENT_REPOSITORY=${REPOSITORY#"-r "}
 315     CLIENT_REPOSITORY_BASE=${REPOSITORY_BASE#"-u "}
 316     key_location=$CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE/$CLIENT_REPOSITORY_KEY
 317     curl $key_location | sudo apt-key add -
 318     sudo add-apt-repository -y "deb [arch=amd64] $CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE $CLIENT_REPOSITORY osmclient IM"
 319     sudo apt-get update
 320     sudo apt-get install -y python3-pip
 321     sudo -H LC_ALL=C python3 -m pip install -U pip
 322     sudo -H LC_ALL=C python3 -m pip install -U python-magic pyangbind verboselogs
 323     sudo apt-get install -y python3-osm-im python3-osmclient
 324     #sed 's,OSM_SOL005=[^$]*,OSM_SOL005=True,' -i ${HOME}/.bashrc
 325     #echo 'export OSM_HOSTNAME=localhost' >> ${HOME}/.bashrc
 326     #echo 'export OSM_SOL005=True' >> ${HOME}/.bashrc
 327     [ -z "$INSTALL_LIGHTWEIGHT" ] && export OSM_HOSTNAME=`lxc list | awk '($2=="SO-ub"){print $6}'`
 328     [ -z "$INSTALL_LIGHTWEIGHT" ] && export OSM_RO_HOSTNAME=`lxc list | awk '($2=="RO"){print $6}'`
 329     echo -e "\nOSM client installed"
 330     if [ -z "$INSTALL_LIGHTWEIGHT" ]; then
 331         echo -e "You might be interested in adding the following OSM client env variables to your .bashrc file:"
 332         echo "     export OSM_HOSTNAME=${OSM_HOSTNAME}"
 333         echo "     export OSM_RO_HOSTNAME=${OSM_RO_HOSTNAME}"
 334     else
 335         echo -e "OSM client assumes that OSM host is running in localhost (127.0.0.1)."
 336         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:"
 337         echo "     export OSM_HOSTNAME=<OSM_host>"
 338     fi
 339     return 0
 340 }
 341
 342 function install_prometheus_nodeexporter(){
 343     if (systemctl -q is-active node_exporter)
 344         then
 345             echo "Node Exporter is already running."
 346         else
 347             echo "Node Exporter is not active, installing..."
 348             if getent passwd node_exporter > /dev/null 2>&1; then
 349                 echo "node_exporter user exists"
 350             else
 351                 echo "Creating user node_exporter"
 352                 sudo useradd --no-create-home --shell /bin/false node_exporter
 353             fi
 354             wget -q https://github.com/prometheus/node_exporter/releases/download/v$PROMETHEUS_NODE_EXPORTER_TAG/node_exporter-$PROMETHEUS_NODE_EXPORTER_TAG.linux-amd64.tar.gz  -P /tmp/
 355             sudo tar -C /tmp -xf /tmp/node_exporter-$PROMETHEUS_NODE_EXPORTER_TAG.linux-amd64.tar.gz
 356             sudo cp /tmp/node_exporter-$PROMETHEUS_NODE_EXPORTER_TAG.linux-amd64/node_exporter /usr/local/bin
 357             sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter
 358             sudo rm -rf /tmp/node_exporter-$PROMETHEUS_NODE_EXPORTER_TAG.linux-amd64*
 359             sudo cp ${OSM_DEVOPS}/installers/docker/prometheus/node_exporter.service /etc/systemd/system/node_exporter.service
 360             sudo systemctl daemon-reload
 361             sudo systemctl restart node_exporter
 362             sudo systemctl enable node_exporter
 363             echo "Node Exporter has been activated in this host."
 364     fi
 365     return 0
 366 }
 367
 368 function uninstall_prometheus_nodeexporter(){
 369     sudo systemctl stop node_exporter
 370     sudo systemctl disable node_exporter
 371     sudo rm /etc/systemd/system/node_exporter.service
 372     sudo systemctl daemon-reload
 373     sudo userdel node_exporter
 374     sudo rm /usr/local/bin/node_exporter
 375     return 0
 376 }
 377
 378 function install_docker_ce() {
 379     # installs and configures Docker CE
 380     echo "Installing Docker CE ..."
 381     sudo apt-get -qq update
 382     sudo apt-get install -y apt-transport-https ca-certificates software-properties-common
 383     curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
 384     sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
 385     sudo apt-get -qq update
 386     sudo apt-get install -y docker-ce
 387     echo "Adding user to group 'docker'"
 388     sudo groupadd -f docker
 389     sudo usermod -aG docker $USER
 390     sleep 2
 391     sudo service docker restart
 392     echo "... restarted Docker service"
 393     sg docker -c "docker version" || FATAL "Docker installation failed"
 394     echo "... Docker CE installation done"
 395     return 0
 396 }
 397
 398 function install_docker_compose() {
 399     # installs and configures docker-compose
 400     echo "Installing Docker Compose ..."
 401     sudo curl -L https://github.com/docker/compose/releases/download/1.18.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
 402     sudo chmod +x /usr/local/bin/docker-compose
 403     echo "... Docker Compose installation done"
 404 }
 405
 406 function install_juju() {
 407     echo "Installing juju"
 408     sudo snap install juju --classic
 409     [[ ":$PATH": != *":/snap/bin:"* ]] && PATH="/snap/bin:${PATH}"
 410     echo "Finished installation of juju"
 411     return 0
 412 }
 413
 414 function juju_createcontroller() {
 415     if ! juju show-controller $OSM_STACK_NAME &> /dev/null; then
 416         # Not found created, create the controller
 417         sudo usermod -a -G lxd ${USER}
 418         sg lxd -c "juju bootstrap --bootstrap-series=xenial $OSM_VCA_CLOUDNAME $OSM_STACK_NAME"
 419     fi
 420     [ $(juju controllers | awk "/^${OSM_STACK_NAME}[\*| ]/{print $1}"|wc -l) -eq 1 ] || FATAL "Juju installation failed"
 421 }
 422
 423 function juju_createproxy() {
 424     check_install_iptables_persistent
 425
 426     if ! sudo iptables -t nat -C PREROUTING -p tcp -m tcp -d $DEFAULT_IP --dport 17070 -j DNAT --to-destination $OSM_VCA_HOST; then
 427         sudo iptables -t nat -A PREROUTING -p tcp -m tcp -d $DEFAULT_IP --dport 17070 -j DNAT --to-destination $OSM_VCA_HOST
 428         sudo netfilter-persistent save
 429     fi
 430 }
 431
 432 function generate_docker_images() {
 433     echo "Pulling and generating docker images"
 434     _build_from=$COMMIT_ID
 435     [ -z "$_build_from" ] && _build_from="master"
 436
 437     echo "OSM Docker images generated from $_build_from"
 438
 439     BUILD_ARGS+=(--build-arg REPOSITORY="$REPOSITORY")
 440     BUILD_ARGS+=(--build-arg RELEASE="$RELEASE")
 441     BUILD_ARGS+=(--build-arg REPOSITORY_KEY="$REPOSITORY_KEY")
 442     BUILD_ARGS+=(--build-arg REPOSITORY_BASE="$REPOSITORY_BASE")
 443
 444     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q KAFKA ; then
 445         sg docker -c "docker pull wurstmeister/zookeeper" || FATAL "cannot get zookeeper docker image"
 446         sg docker -c "docker pull wurstmeister/kafka:${KAFKA_TAG}" || FATAL "cannot get kafka docker image"
 447     fi
 448
 449     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q MONGO ; then
 450         sg docker -c "docker pull mongo" || FATAL "cannot get mongo docker image"
 451     fi
 452
 453     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS ; then
 454         sg docker -c "docker pull prom/prometheus:${PROMETHEUS_TAG}" || FATAL "cannot get prometheus docker image"
 455     fi
 456
 457     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS-CADVISOR ; then
 458         sg docker -c "docker pull google/cadvisor:${PROMETHEUS_CADVISOR_TAG}" || FATAL "cannot get prometheus cadvisor docker image"
 459     fi
 460
 461     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q GRAFANA ; then
 462         sg docker -c "docker pull grafana/grafana:${GRAFANA_TAG}" || FATAL "cannot get grafana docker image"
 463     fi
 464
 465     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q NBI || echo $TO_REBUILD | grep -q KEYSTONE-DB ; then
 466         sg docker -c "docker pull mariadb:${KEYSTONEDB_TAG}" || FATAL "cannot get keystone-db docker image"
 467     fi
 468
 469     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q RO ; then
 470         sg docker -c "docker pull mysql:5" || FATAL "cannot get mysql docker image"
 471     fi
 472
 473     if [ -n "$PULL_IMAGES" ]; then
 474         sg docker -c "docker pull ${DOCKER_USER}/mon:${OSM_DOCKER_TAG}" || FATAL "cannot pull MON docker image"
 475     elif [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q MON ; then
 476         git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/MON
 477         git -C ${LWTEMPDIR}/MON checkout ${COMMIT_ID}
 478         sg docker -c "docker build ${LWTEMPDIR}/MON -f ${LWTEMPDIR}/MON/docker/Dockerfile -t ${DOCKER_USER}/mon --no-cache" || FATAL "cannot build MON docker image"
 479     fi
 480
 481     if [ -n "$PULL_IMAGES" ]; then
 482         sg docker -c "docker pull ${DOCKER_USER}/pol:${OSM_DOCKER_TAG}" || FATAL "cannot pull POL docker image"
 483     elif [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q POL ; then
 484         git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/POL
 485         git -C ${LWTEMPDIR}/POL checkout ${COMMIT_ID}
 486         sg docker -c "docker build ${LWTEMPDIR}/POL -f ${LWTEMPDIR}/POL/docker/Dockerfile -t ${DOCKER_USER}/pol --no-cache" || FATAL "cannot build POL docker image"
 487     fi
 488
 489     if [ -n "$PULL_IMAGES" -a -n "$INSTALL_PLA" ]; then
 490         sg docker -c "docker pull ${DOCKER_USER}/pla:${OSM_DOCKER_TAG}" || FATAL "cannot pull PLA docker image"
 491     elif [ -z "$TO_REBUILD" -a -n "$INSTALL_PLA" ] || echo $TO_REBUILD | grep -q PLA ; then
 492         git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/PLA
 493         git -C ${LWTEMPDIR}/PLA checkout ${COMMIT_ID}
 494         sg docker -c "docker build ${LWTEMPDIR}/PLA -f ${LWTEMPDIR}/PLA/docker/Dockerfile -t ${DOCKER_USER}/pla --no-cache" || FATAL "cannot build PLA docker image"
 495     fi
 496
 497     if [ -n "$PULL_IMAGES" ]; then
 498         sg docker -c "docker pull ${DOCKER_USER}/nbi:${OSM_DOCKER_TAG}" || FATAL "cannot pull NBI docker image"
 499         sg docker -c "docker pull ${DOCKER_USER}/keystone:${OSM_DOCKER_TAG}" || FATAL "cannot pull KEYSTONE docker image"
 500     elif [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q NBI ; then
 501         git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/NBI
 502         git -C ${LWTEMPDIR}/NBI checkout ${COMMIT_ID}
 503         sg docker -c "docker build ${LWTEMPDIR}/NBI -f ${LWTEMPDIR}/NBI/Dockerfile.local -t ${DOCKER_USER}/nbi --no-cache" || FATAL "cannot build NBI docker image"
 504         sg docker -c "docker build ${LWTEMPDIR}/NBI/keystone -f ${LWTEMPDIR}/NBI/keystone/Dockerfile -t ${DOCKER_USER}/keystone --no-cache" || FATAL "cannot build KEYSTONE docker image"
 505     fi
 506
 507     if [ -n "$PULL_IMAGES" ]; then
 508         sg docker -c "docker pull ${DOCKER_USER}/ro:${OSM_DOCKER_TAG}" || FATAL "cannot pull RO docker image"
 509     elif [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q RO ; then
 510         git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/RO
 511         git -C ${LWTEMPDIR}/RO checkout ${COMMIT_ID}
 512         sg docker -c "docker build ${LWTEMPDIR}/RO -f ${LWTEMPDIR}/RO/Dockerfile-local -t ${DOCKER_USER}/ro --no-cache" || FATAL "cannot build RO docker image"
 513     fi
 514
 515     if [ -n "$PULL_IMAGES" ]; then
 516         sg docker -c "docker pull ${DOCKER_USER}/lcm:${OSM_DOCKER_TAG}" || FATAL "cannot pull LCM RO docker image"
 517     elif [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q LCM ; then
 518         git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/LCM
 519         git -C ${LWTEMPDIR}/LCM checkout ${COMMIT_ID}
 520         sg docker -c "docker build ${LWTEMPDIR}/LCM -f ${LWTEMPDIR}/LCM/Dockerfile.local -t ${DOCKER_USER}/lcm --no-cache" || FATAL "cannot build LCM docker image"
 521     fi
 522
 523     if [ -n "$NGUI" ]; then
 524         if [ -n "$PULL_IMAGES" ]; then
 525             sg docker -c "docker pull ${DOCKER_USER}/ng-ui:${OSM_DOCKER_TAG}" || FATAL "cannot pull ng-ui docker image"
 526         elif [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q NG-UI ; then
 527             git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/NG-UI
 528             git -C ${LWTEMPDIR}/NG-UI checkout ${COMMIT_ID}
 529             sg docker -c "docker build ${LWTEMPDIR}/NG-UI -f ${LWTEMPDIR}/NG-UI/docker/Dockerfile -t ${DOCKER_USER}/ng-ui --no-cache" || FATAL "cannot build NG-UI docker image"
 530         fi
 531     else
 532         if [ -n "$PULL_IMAGES" ]; then
 533             sg docker -c "docker pull ${DOCKER_USER}/light-ui:${OSM_DOCKER_TAG}" || FATAL "cannot pull light-ui docker image"
 534         elif [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q LW-UI ; then
 535             git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/LW-UI
 536             git -C ${LWTEMPDIR}/LW-UI checkout ${COMMIT_ID}
 537             sg docker -c "docker build ${LWTEMPDIR}/LW-UI -f ${LWTEMPDIR}/LW-UI/docker/Dockerfile -t ${DOCKER_USER}/light-ui --no-cache" || FATAL "cannot build LW-UI docker image"
 538         fi
 539      fi
 540
 541     if [ -n "$PULL_IMAGES" ]; then
 542         sg docker -c "docker pull ${DOCKER_USER}/osmclient:${OSM_DOCKER_TAG}" || FATAL "cannot pull osmclient docker image"
 543     elif [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q LW-osmclient; then
 544         sg docker -c "docker build -t ${DOCKER_USER}/osmclient ${BUILD_ARGS[@]} -f $OSM_DEVOPS/docker/osmclient ."
 545     fi
 546
 547     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS ; then
 548         sg docker -c "docker pull google/cadvisor:${PROMETHEUS_CADVISOR_TAG}" || FATAL "cannot get prometheus cadvisor docker image"
 549     fi
 550
 551     echo "Finished generation of docker images"
 552 }
 553
 554 function cmp_overwrite() {
 555     file1="$1"
 556     file2="$2"
 557     if ! $(cmp "${file1}" "${file2}" >/dev/null 2>&1); then
 558         if [ -f "${file2}" ]; then
 559             ask_user "The file ${file2} already exists. Overwrite (y/N)? " n && cp -b ${file1} ${file2}
 560         else
 561             cp -b ${file1} ${file2}
 562         fi
 563     fi
 564 }
 565
 566 function generate_docker_env_files() {
 567     echo "Doing a backup of existing env files"
 568     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/keystone-db.env{,~}
 569     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/keystone.env{,~}
 570     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/lcm.env{,~}
 571     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/lwui.env{,~}
 572     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/mon.env{,~}
 573     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/nbi.env{,~}
 574     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/pol.env{,~}
 575     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/ro-db.env{,~}
 576     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/ro.env{,~}
 577
 578     echo "Generating docker env files"
 579     if [ -n "$KUBERNETES" ]; then
 580         #Kubernetes resources
 581         $WORKDIR_SUDO cp -bR ${OSM_DEVOPS}/installers/docker/osm_pods $OSM_DOCKER_WORK_DIR
 582         [ -n "$NGUI" ] && $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/osm_pods/ng-ui.yaml $OSM_K8S_WORK_DIR/ng-ui.yaml && $WORKDIR_SUDO rm $OSM_K8S_WORK_DIR/light-ui.yaml
 583     else
 584         if [ -n "$NGUI" ]; then
 585             # For NG-UI
 586             $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/docker-compose-ngui.yaml $OSM_DOCKER_WORK_DIR/docker-compose.yaml
 587         else
 588             # Docker-compose
 589             $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/docker-compose.yaml $OSM_DOCKER_WORK_DIR/docker-compose.yaml
 590         fi
 591         if [ -n "$INSTALL_PLA" ]; then
 592             $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/osm_pla/docker-compose.yaml $OSM_DOCKER_WORK_DIR/osm_pla/docker-compose.yaml
 593         fi
 594
 595         # Prometheus files
 596         $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/prometheus
 597         $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/prometheus/prometheus.yml $OSM_DOCKER_WORK_DIR/prometheus/prometheus.yml
 598
 599         # Grafana files
 600         $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/grafana
 601         $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/dashboards-osm.yml $OSM_DOCKER_WORK_DIR/grafana/dashboards-osm.yml
 602         $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/datasource-prometheus.yml $OSM_DOCKER_WORK_DIR/grafana/datasource-prometheus.yml
 603         $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/osm-sample-dashboard.json $OSM_DOCKER_WORK_DIR/grafana/osm-sample-dashboard.json
 604         $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/osm-system-dashboard.json $OSM_DOCKER_WORK_DIR/grafana/osm-system-dashboard.json
 605
 606         # Prometheus Exporters files
 607         $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/prometheus_exporters
 608         $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/prometheus_exporters/node_exporter.service $OSM_DOCKER_WORK_DIR/prometheus_exporters/node_exporter.service
 609     fi
 610
 611     # LCM
 612     if [ ! -f $OSM_DOCKER_WORK_DIR/lcm.env ]; then
 613         echo "OSMLCM_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 614     fi
 615
 616     if ! grep -Fq "OSMLCM_VCA_HOST" $OSM_DOCKER_WORK_DIR/lcm.env; then
 617         echo "OSMLCM_VCA_HOST=${OSM_VCA_HOST}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 618     else
 619         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_HOST.*|OSMLCM_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/lcm.env
 620     fi
 621
 622     if ! grep -Fq "OSMLCM_VCA_SECRET" $OSM_DOCKER_WORK_DIR/lcm.env; then
 623         echo "OSMLCM_VCA_SECRET=${OSM_VCA_SECRET}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 624     else
 625         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_SECRET.*|OSMLCM_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/lcm.env
 626     fi
 627
 628     if ! grep -Fq "OSMLCM_VCA_PUBKEY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 629         echo "OSMLCM_VCA_PUBKEY=${OSM_VCA_PUBKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 630     else
 631         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_PUBKEY.*|OSMLCM_VCA_PUBKEY=${OSM_VCA_PUBKEY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 632     fi
 633
 634     if ! grep -Fq "OSMLCM_VCA_CACERT" $OSM_DOCKER_WORK_DIR/lcm.env; then
 635        echo "OSMLCM_VCA_CACERT=${OSM_VCA_CACERT}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 636     else
 637        $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_CACERT.*|OSMLCM_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 638     fi
 639
 640     if ! grep -Fq "OSMLCM_VCA_APIPROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 641         echo "OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 642     else
 643         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_APIPROXY.*|OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 644     fi
 645
 646     if ! grep -Fq "OSMLCM_VCA_ENABLEOSUPGRADE" $OSM_DOCKER_WORK_DIR/lcm.env; then
 647         echo "# OSMLCM_VCA_ENABLEOSUPGRADE=false" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 648     fi
 649
 650     if ! grep -Fq "OSMLCM_VCA_APTMIRROR" $OSM_DOCKER_WORK_DIR/lcm.env; then
 651         echo "# OSMLCM_VCA_APTMIRROR=http://archive.ubuntu.com/ubuntu/" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 652     fi
 653
 654     if ! grep -Fq "OSMLCM_VCA_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env; then
 655         echo "OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 656     else
 657         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_CLOUD.*|OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 658     fi
 659
 660     # RO
 661     MYSQL_ROOT_PASSWORD=$(generate_secret)
 662     if [ ! -f $OSM_DOCKER_WORK_DIR/ro-db.env ]; then
 663         echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/ro-db.env
 664     fi
 665     if [ ! -f $OSM_DOCKER_WORK_DIR/ro.env ]; then
 666         echo "RO_DB_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/ro.env
 667     fi
 668
 669     # Keystone
 670     KEYSTONE_DB_PASSWORD=$(generate_secret)
 671     SERVICE_PASSWORD=$(generate_secret)
 672     if [ ! -f $OSM_DOCKER_WORK_DIR/keystone-db.env ]; then
 673         echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/keystone-db.env
 674     fi
 675     if [ ! -f $OSM_DOCKER_WORK_DIR/keystone.env ]; then
 676         echo "ROOT_DB_PASSWORD=${MYSQL_ROOT_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/keystone.env
 677         echo "KEYSTONE_DB_PASSWORD=${KEYSTONE_DB_PASSWORD}" |$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/keystone.env
 678         echo "SERVICE_PASSWORD=${SERVICE_PASSWORD}" |$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/keystone.env
 679     fi
 680
 681     # NBI
 682     if [ ! -f $OSM_DOCKER_WORK_DIR/nbi.env ]; then
 683         echo "OSMNBI_AUTHENTICATION_SERVICE_PASSWORD=${SERVICE_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/nbi.env
 684         echo "OSMNBI_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/nbi.env
 685     fi
 686
 687     # MON
 688     if [ ! -f $OSM_DOCKER_WORK_DIR/mon.env ]; then
 689         echo "OSMMON_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 690         echo "OSMMON_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/mon" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 691     fi
 692
 693     if ! grep -Fq "OS_NOTIFIER_URI" $OSM_DOCKER_WORK_DIR/mon.env; then
 694         echo "OS_NOTIFIER_URI=http://${DEFAULT_IP}:8662" |$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 695     else
 696         $WORKDIR_SUDO sed -i "s|OS_NOTIFIER_URI.*|OS_NOTIFIER_URI=http://$DEFAULT_IP:8662|g" $OSM_DOCKER_WORK_DIR/mon.env
 697     fi
 698
 699     if ! grep -Fq "OSMMON_VCA_HOST" $OSM_DOCKER_WORK_DIR/mon.env; then
 700         echo "OSMMON_VCA_HOST=${OSM_VCA_HOST}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 701     else
 702         $WORKDIR_SUDO sed -i "s|OSMMON_VCA_HOST.*|OSMMON_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/mon.env
 703     fi
 704
 705     if ! grep -Fq "OSMMON_VCA_SECRET" $OSM_DOCKER_WORK_DIR/mon.env; then
 706         echo "OSMMON_VCA_SECRET=${OSM_VCA_SECRET}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 707     else
 708         $WORKDIR_SUDO sed -i "s|OSMMON_VCA_SECRET.*|OSMMON_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/mon.env
 709     fi
 710
 711     if ! grep -Fq "OSMMON_VCA_CACERT" $OSM_DOCKER_WORK_DIR/mon.env; then
 712        echo "OSMMON_VCA_CACERT=${OSM_VCA_CACERT}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 713     else
 714        $WORKDIR_SUDO sed -i "s|OSMMON_VCA_CACERT.*|OSMMON_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/mon.env
 715     fi
 716
 717
 718     # POL
 719     if [ ! -f $OSM_DOCKER_WORK_DIR/pol.env ]; then
 720         echo "OSMPOL_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/pol" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/pol.env
 721     fi
 722
 723     # LW-UI
 724     if [ ! -f $OSM_DOCKER_WORK_DIR/lwui.env ]; then
 725         echo "OSMUI_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/lwui" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lwui.env
 726     fi
 727
 728     echo "Finished generation of docker env files"
 729 }
 730
 731 function generate_osmclient_script () {
 732     echo "docker run -ti --network net${OSM_STACK_NAME} ${DOCKER_USER}/osmclient:${OSM_DOCKER_TAG}" | $WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/osm
 733     $WORKDIR_SUDO chmod +x "$OSM_DOCKER_WORK_DIR/osm"
 734     echo "osmclient sidecar container can be found at: $OSM_DOCKER_WORK_DIR/osm"
 735 }
 736
 737 #installs kubernetes packages
 738 function install_kube() {
 739     sudo apt-get update && sudo apt-get install -y apt-transport-https
 740     curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
 741     sudo add-apt-repository "deb https://apt.kubernetes.io/ kubernetes-xenial main"
 742     sudo apt-get update
 743     echo "Installing Kubernetes Packages ..."
 744     sudo apt-get install -y kubelet=1.15.0-00 kubeadm=1.15.0-00 kubectl=1.15.0-00
 745 }
 746
 747 #initializes kubernetes control plane
 748 function init_kubeadm() {
 749     sudo swapoff -a
 750     sudo kubeadm init --config $1
 751     sleep 5
 752 }
 753
 754 function kube_config_dir() {
 755     [ ! -d $K8S_MANIFEST_DIR ] && FATAL "Cannot Install Kubernetes"
 756     mkdir -p $HOME/.kube
 757     sudo cp /etc/kubernetes/admin.conf $HOME/.kube/config
 758     sudo chown $(id -u):$(id -g) $HOME/.kube/config
 759 }
 760
 761 #deploys flannel as daemonsets
 762 function deploy_cni_provider() {
 763     CNI_DIR="$(mktemp -d -q --tmpdir "flannel.XXXXXX")"
 764     trap 'rm -rf "${CNI_DIR}"' EXIT
 765     wget -q https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml -P $CNI_DIR
 766     kubectl apply -f $CNI_DIR
 767     [ $? -ne 0 ] && FATAL "Cannot Install Flannel"
 768 }
 769
 770 #creates secrets from env files which will be used by containers
 771 function kube_secrets(){
 772     kubectl create ns $OSM_STACK_NAME
 773     kubectl create secret generic lcm-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/lcm.env
 774     kubectl create secret generic mon-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/mon.env
 775     kubectl create secret generic nbi-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/nbi.env
 776     kubectl create secret generic ro-db-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ro-db.env
 777     kubectl create secret generic ro-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ro.env
 778     kubectl create secret generic keystone-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/keystone.env
 779     kubectl create secret generic lwui-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/lwui.env
 780     kubectl create secret generic pol-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/pol.env
 781 }
 782
 783 #deploys osm pods and services
 784 function deploy_osm_services() {
 785     K8S_MASTER=$(kubectl get nodes | awk '$3~/master/'| awk '{print $1}')
 786     kubectl taint node $K8S_MASTER node-role.kubernetes.io/master:NoSchedule-
 787     sleep 5
 788     kubectl apply -n $OSM_STACK_NAME -f $OSM_K8S_WORK_DIR
 789 }
 790
 791 function deploy_osm_pla_service() {
 792     # corresponding to parse_yaml
 793     [ ! $OSM_DOCKER_TAG == "7" ] && $WORKDIR_SUDO sed -i "s/opensourcemano\/pla:.*/opensourcemano\/pla:$OSM_DOCKER_TAG/g" $OSM_DOCKER_WORK_DIR/osm_pla/pla.yaml
 794     # corresponding to namespace_vol
 795     $WORKDIR_SUDO  sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_DOCKER_WORK_DIR/osm_pla/pla.yaml
 796     # corresponding to deploy_osm_services
 797     kubectl apply -n $OSM_STACK_NAME -f $OSM_DOCKER_WORK_DIR/osm_pla
 798 }
 799
 800 #Install helm and tiller
 801 function install_helm() {
 802     helm > /dev/null 2>&1
 803     if [ $? != 0 ] ; then
 804         # Helm is not installed. Install helm
 805         curl https://get.helm.sh/helm-v2.15.2-linux-amd64.tar.gz --output helm-v2.15.2.tar.gz
 806         tar -zxvf helm-v2.15.2.tar.gz
 807         sudo mv linux-amd64/helm /usr/local/bin/helm
 808         rm -r linux-amd64
 809         rm helm-v2.15.2.tar.gz
 810     fi
 811
 812     # Checking if tiller has being configured
 813     kubectl --namespace kube-system get serviceaccount tiller > /dev/null 2>&1
 814     if [ $? == 1 ] ; then
 815         # tiller account for kubernetes
 816         kubectl --namespace kube-system create serviceaccount tiller
 817         kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
 818         # HELM initialization
 819         helm init --service-account tiller
 820
 821         # Wait for Tiller to be up and running. If timeout expires, continue installing
 822         tiller_timeout=120; counter=0
 823         while (( counter < tiller_timeout ))
 824         do
 825             tiller_status=`kubectl -n kube-system get deployment.apps/tiller-deploy --no-headers |  awk '{print $2'}`
 826             ( [ ! -z "$tiller_status" ] && [ $tiller_status == "1/1" ] ) && break
 827             num=$((counter + 2))
 828             sleep 2
 829         done
 830     fi
 831 }
 832
 833 function parse_yaml() {
 834     osm_services="nbi lcm ro pol mon light-ui ng-ui keystone"
 835     TAG=$1
 836     for osm in $osm_services; do
 837         $WORKDIR_SUDO sed -i "s/opensourcemano\/$osm:.*/$DOCKER_USER\/$osm:$TAG/g" $OSM_K8S_WORK_DIR/$osm.yaml
 838     done
 839 }
 840
 841 function namespace_vol() {
 842     osm_services="nbi lcm ro pol mon kafka mongo mysql"
 843     for osm in $osm_services; do
 844           $WORKDIR_SUDO  sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_K8S_WORK_DIR/$osm.yaml
 845     done
 846 }
 847
 848 function init_docker_swarm() {
 849     if [ "${DEFAULT_MTU}" != "1500" ]; then
 850       DOCKER_NETS=`sg docker -c "docker network list" | awk '{print $2}' | egrep -v "^ID$" | paste -d " " -s`
 851       DOCKER_GW_NET=`sg docker -c "docker network inspect ${DOCKER_NETS}" | grep Subnet | awk -F\" '{print $4}' | egrep "^172" | sort -u | tail -1 |  awk -F\. '{if ($2 != 255) print $1"."$2+1"."$3"."$4; else print "-1";}'`
 852       sg docker -c "docker network create --subnet ${DOCKER_GW_NET} --opt com.docker.network.bridge.name=docker_gwbridge --opt com.docker.network.bridge.enable_icc=false --opt com.docker.network.bridge.enable_ip_masquerade=true --opt com.docker.network.driver.mtu=${DEFAULT_MTU} docker_gwbridge"
 853     fi
 854     sg docker -c "docker swarm init --advertise-addr ${DEFAULT_IP}"
 855     return 0
 856 }
 857
 858 function create_docker_network() {
 859     echo "creating network"
 860     sg docker -c "docker network create --driver=overlay --attachable --opt com.docker.network.driver.mtu=${DEFAULT_MTU} net${OSM_STACK_NAME}"
 861     echo "creating network DONE"
 862 }
 863
 864 function deploy_lightweight() {
 865
 866     echo "Deploying lightweight build"
 867     OSM_NBI_PORT=9999
 868     OSM_RO_PORT=9090
 869     OSM_KEYSTONE_PORT=5000
 870     OSM_UI_PORT=80
 871     OSM_MON_PORT=8662
 872     OSM_PROM_PORT=9090
 873     OSM_PROM_CADVISOR_PORT=8080
 874     OSM_PROM_HOSTPORT=9091
 875     OSM_GRAFANA_PORT=3000
 876     [ -n "$INSTALL_ELK" ] && OSM_ELK_PORT=5601
 877     #[ -n "$INSTALL_PERFMON" ] && OSM_PM_PORT=3000
 878
 879     if [ -n "$NO_HOST_PORTS" ]; then
 880         OSM_PORTS+=(OSM_NBI_PORTS=$OSM_NBI_PORT)
 881         OSM_PORTS+=(OSM_RO_PORTS=$OSM_RO_PORT)
 882         OSM_PORTS+=(OSM_KEYSTONE_PORTS=$OSM_KEYSTONE_PORT)
 883         OSM_PORTS+=(OSM_UI_PORTS=$OSM_UI_PORT)
 884         OSM_PORTS+=(OSM_MON_PORTS=$OSM_MON_PORT)
 885         OSM_PORTS+=(OSM_PROM_PORTS=$OSM_PROM_PORT)
 886         OSM_PORTS+=(OSM_PROM_CADVISOR_PORTS=$OSM_PROM_CADVISOR_PORT)
 887         OSM_PORTS+=(OSM_GRAFANA_PORTS=$OSM_GRAFANA_PORT)
 888         #[ -n "$INSTALL_PERFMON" ] && OSM_PORTS+=(OSM_PM_PORTS=$OSM_PM_PORT)
 889         [ -n "$INSTALL_ELK" ] && OSM_PORTS+=(OSM_ELK_PORTS=$OSM_ELK_PORT)
 890     else
 891         OSM_PORTS+=(OSM_NBI_PORTS=$OSM_NBI_PORT:$OSM_NBI_PORT)
 892         OSM_PORTS+=(OSM_RO_PORTS=$OSM_RO_PORT:$OSM_RO_PORT)
 893         OSM_PORTS+=(OSM_KEYSTONE_PORTS=$OSM_KEYSTONE_PORT:$OSM_KEYSTONE_PORT)
 894         OSM_PORTS+=(OSM_UI_PORTS=$OSM_UI_PORT:$OSM_UI_PORT)
 895         OSM_PORTS+=(OSM_MON_PORTS=$OSM_MON_PORT:$OSM_MON_PORT)
 896         OSM_PORTS+=(OSM_PROM_PORTS=$OSM_PROM_HOSTPORT:$OSM_PROM_PORT)
 897         OSM_PORTS+=(OSM_PROM_CADVISOR_PORTS=$OSM_PROM_CADVISOR_PORT:$OSM_PROM_CADVISOR_PORT)
 898         OSM_PORTS+=(OSM_GRAFANA_PORTS=$OSM_GRAFANA_PORT:$OSM_GRAFANA_PORT)
 899         #[ -n "$INSTALL_PERFMON" ] && OSM_PORTS+=(OSM_PM_PORTS=$OSM_PM_PORT:$OSM_PM_PORT)
 900         [ -n "$INSTALL_ELK" ] && OSM_PORTS+=(OSM_ELK_PORTS=$OSM_ELK_PORT:$OSM_ELK_PORT)
 901     fi
 902     echo "export ${OSM_PORTS[@]}" | $WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/osm_ports.sh
 903     echo "export OSM_NETWORK=net${OSM_STACK_NAME}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
 904     echo "export TAG=${OSM_DOCKER_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
 905     echo "export DOCKER_USER=${DOCKER_USER}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
 906     echo "export KAFKA_TAG=${KAFKA_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
 907     echo "export PROMETHEUS_TAG=${PROMETHEUS_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
 908     echo "export KEYSTONEDB_TAG=${KEYSTONEDB_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
 909     echo "export PROMETHEUS_CADVISOR_TAG=${PROMETHEUS_CADVISOR_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
 910     echo "export GRAFANA_TAG=${GRAFANA_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
 911
 912     pushd $OSM_DOCKER_WORK_DIR
 913     if [ -n "$INSTALL_PLA" ]; then
 914         sg docker -c ". ./osm_ports.sh; docker stack deploy -c $OSM_DOCKER_WORK_DIR/docker-compose.yaml -c $OSM_DOCKER_WORK_DIR/osm_pla/docker-compose.yaml $OSM_STACK_NAME"
 915     else
 916         sg docker -c ". ./osm_ports.sh; docker stack deploy -c $OSM_DOCKER_WORK_DIR/docker-compose.yaml $OSM_STACK_NAME"
 917     fi
 918     popd
 919
 920     echo "Finished deployment of lightweight build"
 921 }
 922
 923 function deploy_elk() {
 924     echo "Pulling docker images for ELK"
 925     sg docker -c "docker pull docker.elastic.co/elasticsearch/elasticsearch-oss:${ELASTIC_VERSION}" || FATAL "cannot get elasticsearch docker image"
 926     sg docker -c "docker pull docker.elastic.co/beats/metricbeat:${ELASTIC_VERSION}" || FATAL "cannot get metricbeat docker image"
 927     sg docker -c "docker pull docker.elastic.co/beats/filebeat:${ELASTIC_VERSION}" || FATAL "cannot get filebeat docker image"
 928     sg docker -c "docker pull docker.elastic.co/kibana/kibana-oss:${ELASTIC_VERSION}" || FATAL "cannot get kibana docker image"
 929     sg docker -c "docker pull bobrik/curator:${ELASTIC_CURATOR_VERSION}" || FATAL "cannot get curator docker image"
 930     echo "Finished pulling elk docker images"
 931     $WORKDIR_SUDO mkdir -p "$OSM_DOCKER_WORK_DIR/osm_elk"
 932     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/osm_elk/* $OSM_DOCKER_WORK_DIR/osm_elk
 933     remove_stack osm_elk
 934     echo "Deploying ELK stack"
 935     sg docker -c "OSM_NETWORK=net${OSM_STACK_NAME} docker stack deploy -c $OSM_DOCKER_WORK_DIR/osm_elk/docker-compose.yml osm_elk"
 936     echo "Waiting for ELK stack to be up and running"
 937     time=0
 938     step=5
 939     timelength=40
 940     elk_is_up=1
 941     while [ $time -le $timelength ]; do
 942         if [[ $(curl -f -XGET http://127.0.0.1:5601/status -I 2>/dev/null | grep "HTTP/1.1 200 OK" | wc -l ) -eq 1 ]]; then
 943             elk_is_up=0
 944             break
 945         fi
 946         sleep $step
 947         time=$((time+step))
 948     done
 949     if [ $elk_is_up -eq 0 ]; then
 950         echo "ELK is up and running. Trying to create index pattern..."
 951         #Create index pattern
 952         curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
 953           "http://127.0.0.1:5601/api/saved_objects/index-pattern/filebeat-*" \
 954           -d"{\"attributes\":{\"title\":\"filebeat-*\",\"timeFieldName\":\"@timestamp\"}}" 2>/dev/null
 955         #Make it the default index
 956         curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
 957           "http://127.0.0.1:5601/api/kibana/settings/defaultIndex" \
 958           -d"{\"value\":\"filebeat-*\"}" 2>/dev/null
 959     else
 960         echo "Cannot connect to Kibana to create index pattern."
 961         echo "Once Kibana is running, you can use the following instructions to create index pattern:"
 962         echo 'curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
 963           "http://127.0.0.1:5601/api/saved_objects/index-pattern/filebeat-*" \
 964           -d"{\"attributes\":{\"title\":\"filebeat-*\",\"timeFieldName\":\"@timestamp\"}}"'
 965         echo 'curl -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
 966           "http://127.0.0.1:5601/api/kibana/settings/defaultIndex" \
 967           -d"{\"value\":\"filebeat-*\"}"'
 968     fi
 969     echo "Finished deployment of ELK stack"
 970     return 0
 971 }
 972
 973 function install_lightweight() {
 974     [ "${OSM_STACK_NAME}" == "osm" ] || OSM_DOCKER_WORK_DIR="$OSM_WORK_DIR/stack/$OSM_STACK_NAME"
 975     [ -n "$KUBERNETES" ] && OSM_K8S_WORK_DIR="$OSM_DOCKER_WORK_DIR/osm_pods" && OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
 976     [ ! -d "$OSM_DOCKER_WORK_DIR" ] && $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR
 977     [ ! -d "$OSM_DOCKER_WORK_DIR/osm_pla" -a -n "$INSTALL_PLA" ] && $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/osm_pla
 978     [ -n "$KUBERNETES" ] && $WORKDIR_SUDO cp -b $OSM_DEVOPS/installers/docker/cluster-config.yaml $OSM_DOCKER_WORK_DIR/cluster-config.yaml
 979
 980     track checkingroot
 981     [ "$USER" == "root" ] && FATAL "You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges."
 982     track noroot
 983
 984     if [ -n "$KUBERNETES" ]; then
 985         [ -z "$ASSUME_YES" ] && ! ask_user "The installation will do the following
 986         1. Install and configure LXD
 987         2. Install juju
 988         3. Install docker CE
 989         4. Disable swap space
 990         5. Install and initialize Kubernetes
 991         as pre-requirements.
 992         Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1
 993
 994     else
 995         [ -z "$ASSUME_YES" ] && ! ask_user "The installation will configure LXD, install juju, install docker CE and init a docker swarm, as pre-requirements. Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1
 996     fi
 997     track proceed
 998
 999     echo "Installing lightweight build of OSM"
1000     LWTEMPDIR="$(mktemp -d -q --tmpdir "installosmlight.XXXXXX")"
1001     trap 'rm -rf "${LWTEMPDIR}"' EXIT
1002     DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}')
1003     [ -z "$DEFAULT_IF" ] && DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
1004     [ -z "$DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0"
1005     DEFAULT_IP=`ip -o -4 a |grep ${DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]}'`
1006     [ -z "$DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route"
1007     DEFAULT_MTU=$(ip addr show ${DEFAULT_IF} | perl -ne 'if (/mtu\s(\d+)/) {print $1;}')
1008
1009     # if no host is passed in, we need to install lxd/juju, unless explicilty asked not to
1010     if [ -z "$OSM_VCA_HOST" ] && [ -z "$INSTALL_NOLXD" ] && [ -z "$LXD_CLOUD_FILE" ]; then
1011         need_packages_lw="snapd"
1012         echo -e "Checking required packages: $need_packages_lw"
1013         dpkg -l $need_packages_lw &>/dev/null \
1014           || ! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1015           || sudo apt-get update \
1016           || FATAL "failed to run apt-get update"
1017         dpkg -l $need_packages_lw &>/dev/null \
1018           || ! echo -e "Installing $need_packages_lw requires root privileges." \
1019           || sudo apt-get install -y $need_packages_lw \
1020           || FATAL "failed to install $need_packages_lw"
1021         install_lxd
1022     fi
1023
1024     track prereqok
1025
1026     [ -z "$INSTALL_NOJUJU" ] && install_juju
1027     track juju_install
1028
1029     if [ -z "$OSM_VCA_HOST" ]; then
1030         if [ -z "$CONTROLLER_NAME" ]; then
1031             if [ -n "$LXD_CLOUD_FILE" ]; then
1032                 [ -z "$LXD_CRED_FILE" ] && FATAL "The installer needs the LXD credential yaml if the LXD is external"
1033                 OSM_VCA_CLOUDNAME="lxd-cloud"
1034                 juju add-cloud $OSM_VCA_CLOUDNAME $LXD_CLOUD_FILE --force || juju update-cloud $OSM_VCA_CLOUDNAME --client -f $LXD_CLOUD_FILE
1035                 juju add-credential $OSM_VCA_CLOUDNAME -f $LXD_CRED_FILE || juju update-credential $OSM_VCA_CLOUDNAME lxd-cloud-creds -f $LXD_CRED_FILE
1036             fi
1037             juju_createcontroller
1038         else
1039             OSM_VCA_CLOUDNAME="lxd-cloud"
1040             if [ -n "$LXD_CLOUD_FILE" ]; then
1041                 [ -z "$LXD_CRED_FILE" ] && FATAL "The installer needs the LXD credential yaml if the LXD is external"
1042                 juju add-cloud -c $CONTROLLER_NAME $OSM_VCA_CLOUDNAME $LXD_CLOUD_FILE --force || juju update-cloud lxd-cloud -c $CONTROLLER_NAME -f $LXD_CLOUD_FILE
1043                 juju add-credential -c $CONTROLLER_NAME $OSM_VCA_CLOUDNAME -f $LXD_CRED_FILE || juju update-credential lxd-cloud -c $CONTROLLER_NAME -f $LXD_CRED_FILE
1044             else
1045                 mkdir -p ~/.osm
1046                 cat << EOF > ~/.osm/lxd-cloud.yaml
1047 clouds:
1048   lxd-cloud:
1049     type: lxd
1050     auth-types: [certificate]
1051     endpoint: "https://$DEFAULT_IP:8443"
1052     config:
1053       ssl-hostname-verification: false
1054 EOF
1055                 openssl req -nodes -new -x509 -keyout ~/.osm/client.key -out ~/.osm/client.crt -days 365 -subj "/C=FR/ST=Nice/L=Nice/O=ETSI/OU=OSM/CN=osm.etsi.org"
1056                 local server_cert=`cat /var/snap/lxd/common/lxd/server.crt | sed 's/^/        /'`
1057                 local client_cert=`cat ~/.osm/client.crt | sed 's/^/        /'`
1058                 local client_key=`cat ~/.osm/client.key | sed 's/^/        /'`
1059                 cat << EOF > ~/.osm/lxd-credentials.yaml
1060 credentials:
1061   lxd-cloud:
1062     lxd-cloud:
1063       auth-type: certificate
1064       server-cert: |
1065 $server_cert
1066       client-cert: |
1067 $client_cert
1068       client-key: |
1069 $client_key
1070 EOF
1071                 lxc config trust add local: ~/.osm/client.crt
1072                 juju add-cloud -c $CONTROLLER_NAME $OSM_VCA_CLOUDNAME ~/.osm/lxd-cloud.yaml --force || juju update-cloud lxd-cloud -c $CONTROLLER_NAME -f ~/.osm/lxd-cloud.yaml
1073                 juju add-credential -c $CONTROLLER_NAME $OSM_VCA_CLOUDNAME -f ~/.osm/lxd-credentials.yaml || juju update-credential lxd-cloud -c $CONTROLLER_NAME -f ~/.osm/lxd-credentials.yaml
1074             fi
1075         fi
1076         [ -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}'`
1077         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`juju show-controller $CONTROLLER_NAME |grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
1078         [ -z "$OSM_VCA_HOST" ] && FATAL "Cannot obtain juju controller IP address"
1079     fi
1080     track juju_controller
1081
1082     if [ -z "$OSM_VCA_SECRET" ]; then
1083         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $OSM_STACK_NAME)
1084         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $CONTROLLER_NAME)
1085         [ -z "$OSM_VCA_SECRET" ] && FATAL "Cannot obtain juju secret"
1086     fi
1087     if [ -z "$OSM_VCA_PUBKEY" ]; then
1088         OSM_VCA_PUBKEY=$(cat $HOME/.local/share/juju/ssh/juju_id_rsa.pub)
1089         [ -z "$OSM_VCA_PUBKEY" ] && FATAL "Cannot obtain juju public key"
1090     fi
1091     if [ -z "$OSM_VCA_CACERT" ]; then
1092         [ -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)
1093         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $CONTROLLER_NAME '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
1094        [ -z "$OSM_VCA_CACERT" ] && FATAL "Cannot obtain juju CA certificate"
1095     fi
1096     if [ -z "$OSM_VCA_APIPROXY" ]; then
1097         OSM_VCA_APIPROXY=$DEFAULT_IP
1098         [ -z "$OSM_VCA_APIPROXY" ] && FATAL "Cannot obtain juju api proxy"
1099     fi
1100     juju_createproxy
1101     track juju
1102
1103     if [ -z "$OSM_DATABASE_COMMONKEY" ]; then
1104         OSM_DATABASE_COMMONKEY=$(generate_secret)
1105         [ -z "OSM_DATABASE_COMMONKEY" ] && FATAL "Cannot generate common db secret"
1106     fi
1107
1108     [ -n "$INSTALL_NODOCKER" ] || install_docker_ce
1109     track docker_ce
1110
1111     #Installs Kubernetes and deploys osm services
1112     if [ -n "$KUBERNETES" ]; then
1113         install_kube
1114         track install_k8s
1115         init_kubeadm $OSM_DOCKER_WORK_DIR/cluster-config.yaml
1116         kube_config_dir
1117         track init_k8s
1118     else
1119         #install_docker_compose
1120         [ -n "$INSTALL_NODOCKER" ] || init_docker_swarm
1121         track docker_swarm
1122     fi
1123
1124     [ -z "$DOCKER_NOBUILD" ] && generate_docker_images
1125     track docker_build
1126
1127     generate_docker_env_files
1128
1129     if [ -n "$KUBERNETES" ]; then
1130         if [ -n "$INSTALL_K8S_MONITOR" ]; then
1131             # uninstall OSM MONITORING
1132             uninstall_k8s_monitoring
1133             track uninstall_k8s_monitoring
1134         fi
1135         #remove old namespace
1136         remove_k8s_namespace $OSM_STACK_NAME
1137         deploy_cni_provider
1138         kube_secrets
1139         [ ! $OSM_DOCKER_TAG == "7" ] && parse_yaml $OSM_DOCKER_TAG
1140         namespace_vol
1141         deploy_osm_services
1142         if [ -n "$INSTALL_PLA"]; then
1143             # optional PLA install
1144             deploy_osm_pla_service
1145         fi
1146         track deploy_osm_services_k8s
1147         if [ -n "$INSTALL_K8S_MONITOR" ]; then
1148             # install OSM MONITORING
1149             install_k8s_monitoring
1150             track install_k8s_monitoring
1151         fi
1152     else
1153         # remove old stack
1154         remove_stack $OSM_STACK_NAME
1155         create_docker_network
1156         deploy_lightweight
1157         generate_osmclient_script
1158         track docker_deploy
1159         install_prometheus_nodeexporter
1160         track nodeexporter
1161         [ -n "$INSTALL_VIMEMU" ] && install_vimemu && track vimemu
1162         [ -n "$INSTALL_ELK" ] && deploy_elk && track elk
1163     fi
1164
1165     [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
1166     track osmclient
1167
1168     wget -q -O- https://osm-download.etsi.org/ftp/osm-7.0-seven/README2.txt &> /dev/null
1169     track end
1170     return 0
1171 }
1172
1173 function install_vimemu() {
1174     echo "\nInstalling vim-emu"
1175     EMUTEMPDIR="$(mktemp -d -q --tmpdir "installosmvimemu.XXXXXX")"
1176     trap 'rm -rf "${EMUTEMPDIR}"' EXIT
1177     # install prerequisites (OVS is a must for the emulator to work)
1178     sudo apt-get install openvswitch-switch
1179     # clone vim-emu repository (attention: branch is currently master only)
1180     echo "Cloning vim-emu repository ..."
1181     git clone https://osm.etsi.org/gerrit/osm/vim-emu.git $EMUTEMPDIR
1182     # build vim-emu docker
1183     echo "Building vim-emu Docker container..."
1184
1185     sg docker -c "docker build -t vim-emu-img -f $EMUTEMPDIR/Dockerfile --no-cache $EMUTEMPDIR/" || FATAL "cannot build vim-emu-img docker image"
1186     # start vim-emu container as daemon
1187     echo "Starting vim-emu Docker container 'vim-emu' ..."
1188     if [ -n "$INSTALL_LIGHTWEIGHT" ]; then
1189         # in lightweight mode, the emulator needs to be attached to netOSM
1190         sg docker -c "docker run --name vim-emu -t -d --restart always --privileged --pid='host' --network=net${OSM_STACK_NAME} -v /var/run/docker.sock:/var/run/docker.sock vim-emu-img python examples/osm_default_daemon_topology_2_pop.py"
1191     else
1192         # classic build mode
1193         sg docker -c "docker run --name vim-emu -t -d --restart always --privileged --pid='host' -v /var/run/docker.sock:/var/run/docker.sock vim-emu-img python examples/osm_default_daemon_topology_2_pop.py"
1194     fi
1195     echo "Waiting for 'vim-emu' container to start ..."
1196     sleep 5
1197     export VIMEMU_HOSTNAME=$(sg docker -c "docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' vim-emu")
1198     echo "vim-emu running at ${VIMEMU_HOSTNAME} ..."
1199     # print vim-emu connection info
1200     echo -e "\nYou might be interested in adding the following vim-emu env variables to your .bashrc file:"
1201     echo "     export VIMEMU_HOSTNAME=${VIMEMU_HOSTNAME}"
1202     echo -e "To add the emulated VIM to OSM you should do:"
1203     echo "     osm vim-create --name emu-vim1 --user username --password password --auth_url http://${VIMEMU_HOSTNAME}:6001/v2.0 --tenant tenantName --account_type openstack"
1204 }
1205
1206 function install_k8s_monitoring() {
1207     # install OSM monitoring
1208     $WORKDIR_SUDO chmod +x $OSM_DEVOPS/installers/k8s/*.sh
1209     $WORKDIR_SUDO $OSM_DEVOPS/installers/k8s/install_osm_k8s_monitoring.sh
1210 }
1211
1212 function uninstall_k8s_monitoring() {
1213     # uninstall OSM monitoring
1214     $WORKDIR_SUDO $OSM_DEVOPS/installers/k8s/uninstall_osm_k8s_monitoring.sh
1215 }
1216
1217 function dump_vars(){
1218     echo "DEVELOP=$DEVELOP"
1219     echo "INSTALL_FROM_SOURCE=$INSTALL_FROM_SOURCE"
1220     echo "UNINSTALL=$UNINSTALL"
1221     echo "UPDATE=$UPDATE"
1222     echo "RECONFIGURE=$RECONFIGURE"
1223     echo "TEST_INSTALLER=$TEST_INSTALLER"
1224     echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
1225     echo "INSTALL_PLA=$INSTALL_PLA"
1226     echo "INSTALL_LXD=$INSTALL_LXD"
1227     echo "INSTALL_LIGHTWEIGHT=$INSTALL_LIGHTWEIGHT"
1228     echo "INSTALL_ONLY=$INSTALL_ONLY"
1229     echo "INSTALL_ELK=$INSTALL_ELK"
1230     #echo "INSTALL_PERFMON=$INSTALL_PERFMON"
1231     echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
1232     echo "TO_REBUILD=$TO_REBUILD"
1233     echo "INSTALL_NOLXD=$INSTALL_NOLXD"
1234     echo "INSTALL_NODOCKER=$INSTALL_NODOCKER"
1235     echo "INSTALL_NOJUJU=$INSTALL_NOJUJU"
1236     echo "RELEASE=$RELEASE"
1237     echo "REPOSITORY=$REPOSITORY"
1238     echo "REPOSITORY_BASE=$REPOSITORY_BASE"
1239     echo "REPOSITORY_KEY=$REPOSITORY_KEY"
1240     echo "OSM_DEVOPS=$OSM_DEVOPS"
1241     echo "OSM_VCA_HOST=$OSM_VCA_HOST"
1242     echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
1243     echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
1244     echo "NO_HOST_PORTS=$NO_HOST_PORTS"
1245     echo "DOCKER_NOBUILD=$DOCKER_NOBUILD"
1246     echo "WORKDIR_SUDO=$WORKDIR_SUDO"
1247     echo "OSM_WORK_DIR=$OSM_STACK_NAME"
1248     echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
1249     echo "DOCKER_USER=$DOCKER_USER"
1250     echo "OSM_STACK_NAME=$OSM_STACK_NAME"
1251     echo "PULL_IMAGES=$PULL_IMAGES"
1252     echo "KUBERNETES=$KUBERNETES"
1253     echo "NGUI=$NGUI"
1254     echo "SHOWOPTS=$SHOWOPTS"
1255     echo "Install from specific refspec (-b): $COMMIT_ID"
1256 }
1257
1258 function track(){
1259     ctime=`date +%s`
1260     duration=$((ctime - SESSION_ID))
1261     url="http://www.woopra.com/track/ce?project=osm.etsi.org&cookie=${SESSION_ID}"
1262     #url="${url}&ce_campaign_name=${CAMPAIGN_NAME}"
1263     event_name="bin"
1264     [ -z "$INSTALL_LIGHTWEIGHT" ] && [ -n "$INSTALL_FROM_SOURCE" ] && event_name="binsrc"
1265     [ -z "$INSTALL_LIGHTWEIGHT" ] && [ -n "$INSTALL_FROM_LXDIMAGES" ] && event_name="lxd"
1266     [ -n "$INSTALL_LIGHTWEIGHT" ] && event_name="lw"
1267     event_name="${event_name}_$1"
1268     url="${url}&event=${event_name}&ce_duration=${duration}"
1269     wget -q -O /dev/null $url
1270 }
1271
1272 UNINSTALL=""
1273 DEVELOP=""
1274 UPDATE=""
1275 RECONFIGURE=""
1276 TEST_INSTALLER=""
1277 INSTALL_LXD=""
1278 SHOWOPTS=""
1279 COMMIT_ID=""
1280 ASSUME_YES=""
1281 INSTALL_FROM_SOURCE=""
1282 RELEASE="ReleaseSEVEN"
1283 REPOSITORY="stable"
1284 INSTALL_VIMEMU=""
1285 INSTALL_PLA=""
1286 LXD_REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/lxd"
1287 LXD_REPOSITORY_PATH=""
1288 INSTALL_LIGHTWEIGHT="y"
1289 INSTALL_ONLY=""
1290 INSTALL_ELK=""
1291 TO_REBUILD=""
1292 INSTALL_NOLXD=""
1293 INSTALL_NODOCKER=""
1294 INSTALL_NOJUJU=""
1295 KUBERNETES=""
1296 NGUI=""
1297 INSTALL_K8S_MONITOR=""
1298 INSTALL_NOHOSTCLIENT=""
1299 SESSION_ID=`date +%s`
1300 OSM_DEVOPS=
1301 OSM_VCA_HOST=
1302 OSM_VCA_SECRET=
1303 OSM_VCA_PUBKEY=
1304 OSM_VCA_CLOUDNAME="localhost"
1305 OSM_STACK_NAME=osm
1306 NO_HOST_PORTS=""
1307 DOCKER_NOBUILD=""
1308 REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
1309 REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian"
1310 WORKDIR_SUDO=sudo
1311 OSM_WORK_DIR="/etc/osm"
1312 OSM_DOCKER_WORK_DIR="/etc/osm/docker"
1313 OSM_K8S_WORK_DIR="${OSM_DOCKER_WORK_DIR}/osm_pods"
1314 OSM_HOST_VOL="/var/lib/osm"
1315 OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1316 OSM_DOCKER_TAG=latest
1317 DOCKER_USER=opensourcemano
1318 PULL_IMAGES="y"
1319 KAFKA_TAG=2.11-1.0.2
1320 PROMETHEUS_TAG=v2.4.3
1321 GRAFANA_TAG=latest
1322 PROMETHEUS_NODE_EXPORTER_TAG=0.18.1
1323 PROMETHEUS_CADVISOR_TAG=latest
1324 KEYSTONEDB_TAG=10
1325 OSM_DATABASE_COMMONKEY=
1326 ELASTIC_VERSION=6.4.2
1327 ELASTIC_CURATOR_VERSION=5.5.4
1328 POD_NETWORK_CIDR=10.244.0.0/16
1329 K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
1330 RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
1331
1332 while getopts ":b:r:c:n:k:u:R:D:o:m:H:S:s:w:t:U:P:A:l:L:K:-: hy" o; do
1333     case "${o}" in
1334         b)
1335             COMMIT_ID=${OPTARG}
1336             PULL_IMAGES=""
1337             ;;
1338         r)
1339             REPOSITORY="${OPTARG}"
1340             REPO_ARGS+=(-r "$REPOSITORY")
1341             ;;
1342         c)
1343             [ "${OPTARG}" == "swarm" ] && continue
1344             [ "${OPTARG}" == "k8s" ] && KUBERNETES="y" && continue
1345             echo -e "Invalid argument for -i : ' $OPTARG'\n" >&2
1346             usage && exit 1
1347             ;;
1348         n)
1349             [ "${OPTARG}" == "lwui" ] && continue
1350             [ "${OPTARG}" == "ngui" ] && NGUI="y" && continue
1351             echo -e "Invalid argument for -n : ' $OPTARG'\n" >&2
1352             usage && exit 1
1353             ;;
1354         k)
1355             REPOSITORY_KEY="${OPTARG}"
1356             REPO_ARGS+=(-k "$REPOSITORY_KEY")
1357             ;;
1358         u)
1359             REPOSITORY_BASE="${OPTARG}"
1360             REPO_ARGS+=(-u "$REPOSITORY_BASE")
1361             ;;
1362         R)
1363             RELEASE="${OPTARG}"
1364             REPO_ARGS+=(-R "$RELEASE")
1365             ;;
1366         D)
1367             OSM_DEVOPS="${OPTARG}"
1368             ;;
1369         o)
1370             INSTALL_ONLY="y"
1371             [ "${OPTARG}" == "vimemu" ] && INSTALL_VIMEMU="y" && continue
1372             [ "${OPTARG}" == "elk_stack" ] && INSTALL_ELK="y" && continue
1373             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1374             ;;
1375         m)
1376             [ "${OPTARG}" == "LW-UI" ] && TO_REBUILD="$TO_REBUILD LW-UI" && continue
1377             [ "${OPTARG}" == "NBI" ] && TO_REBUILD="$TO_REBUILD NBI" && continue
1378             [ "${OPTARG}" == "LCM" ] && TO_REBUILD="$TO_REBUILD LCM" && continue
1379             [ "${OPTARG}" == "RO" ] && TO_REBUILD="$TO_REBUILD RO" && continue
1380             [ "${OPTARG}" == "MON" ] && TO_REBUILD="$TO_REBUILD MON" && continue
1381             [ "${OPTARG}" == "POL" ] && TO_REBUILD="$TO_REBUILD POL" && continue
1382             [ "${OPTARG}" == "KAFKA" ] && TO_REBUILD="$TO_REBUILD KAFKA" && continue
1383             [ "${OPTARG}" == "MONGO" ] && TO_REBUILD="$TO_REBUILD MONGO" && continue
1384             [ "${OPTARG}" == "PROMETHEUS" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS" && continue
1385             [ "${OPTARG}" == "PROMETHEUS-CADVISOR" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS-CADVISOR" && continue
1386             [ "${OPTARG}" == "KEYSTONE-DB" ] && TO_REBUILD="$TO_REBUILD KEYSTONE-DB" && continue
1387             [ "${OPTARG}" == "GRAFANA" ] && TO_REBUILD="$TO_REBUILD GRAFANA" && continue
1388             [ "${OPTARG}" == "NONE" ] && TO_REBUILD="$TO_REBUILD NONE" && continue
1389             [ "${OPTARG}" == "PLA" ] && TO_REBUILD="$TO_REBUILD PLA" && continue
1390             ;;
1391         H)
1392             OSM_VCA_HOST="${OPTARG}"
1393             ;;
1394         S)
1395             OSM_VCA_SECRET="${OPTARG}"
1396             ;;
1397         s)
1398             OSM_STACK_NAME="${OPTARG}" && [ -n "$KUBERNETES" ] && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
1399             ;;
1400         w)
1401             # when specifying workdir, do not use sudo for access
1402             WORKDIR_SUDO=
1403             OSM_WORK_DIR="${OPTARG}"
1404             ;;
1405         t)
1406             OSM_DOCKER_TAG="${OPTARG}"
1407             ;;
1408         U)
1409             DOCKER_USER="${OPTARG}"
1410             ;;
1411         P)
1412             OSM_VCA_PUBKEY=$(cat ${OPTARG})
1413             ;;
1414         A)
1415             OSM_VCA_APIPROXY="${OPTARG}"
1416             ;;
1417         l)
1418             LXD_CLOUD_FILE="${OPTARG}"
1419             ;;
1420         L)
1421             LXD_CRED_FILE="${OPTARG}"
1422             ;;
1423         K)
1424             CONTROLLER_NAME="${OPTARG}"
1425             ;;
1426         -)
1427             [ "${OPTARG}" == "help" ] && usage && exit 0
1428             [ "${OPTARG}" == "source" ] && INSTALL_FROM_SOURCE="y" && PULL_IMAGES="" && continue
1429             [ "${OPTARG}" == "develop" ] && DEVELOP="y" && continue
1430             [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue
1431             [ "${OPTARG}" == "update" ] && UPDATE="y" && continue
1432             [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE="y" && continue
1433             [ "${OPTARG}" == "test" ] && TEST_INSTALLER="y" && continue
1434             [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD="y" && continue
1435             [ "${OPTARG}" == "nolxd" ] && INSTALL_NOLXD="y" && continue
1436             [ "${OPTARG}" == "nodocker" ] && INSTALL_NODOCKER="y" && continue
1437             [ "${OPTARG}" == "lightweight" ] && INSTALL_LIGHTWEIGHT="y" && continue
1438             [ "${OPTARG}" == "vimemu" ] && INSTALL_VIMEMU="y" && continue
1439             [ "${OPTARG}" == "elk_stack" ] && INSTALL_ELK="y" && continue
1440             [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue
1441             [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS="y" && continue
1442             [ "${OPTARG}" == "nojuju" ] && INSTALL_NOJUJU="y" && continue
1443             [ "${OPTARG}" == "nodockerbuild" ] && DOCKER_NOBUILD="y" && continue
1444             [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue
1445             [ "${OPTARG}" == "pullimages" ] && continue
1446             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1447             [ "${OPTARG}" == "charmed" ] && CHARMED="y" && continue
1448             [ "${OPTARG}" == "bundle" ] && continue
1449             [ "${OPTARG}" == "kubeconfig" ] && continue
1450             [ "${OPTARG}" == "lxdendpoint" ] && continue
1451             [ "${OPTARG}" == "lxdcert" ] && continue
1452             [ "${OPTARG}" == "microstack" ] && continue
1453             [ "${OPTARG}" == "tag" ] && continue
1454             [ "${OPTARG}" == "pla" ] && INSTALL_PLA="y" && continue
1455             echo -e "Invalid option: '--$OPTARG'\n" >&2
1456             usage && exit 1
1457             ;;
1458         :)
1459             echo "Option -$OPTARG requires an argument" >&2
1460             usage && exit 1
1461             ;;
1462         \?)
1463             echo -e "Invalid option: '-$OPTARG'\n" >&2
1464             usage && exit 1
1465             ;;
1466         h)
1467             usage && exit 0
1468             ;;
1469         y)
1470             ASSUME_YES="y"
1471             ;;
1472         *)
1473             usage && exit 1
1474             ;;
1475     esac
1476 done
1477
1478 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" != " NONE" ] && echo $TO_REBUILD | grep -q NONE && FATAL "Incompatible option: -m NONE cannot be used with other -m options"
1479 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" == " PLA" ] && [ -z "$INSTALL_PLA" ] && FATAL "Incompatible option: -m PLA cannot be used without --pla option"
1480
1481 if [ -n "$SHOWOPTS" ]; then
1482     dump_vars
1483     exit 0
1484 fi
1485
1486 if [ -n "$CHARMED" ]; then
1487      if [ -n "$UNINSTALL" ]; then
1488         /usr/share/osm-devops/installers/charmed_uninstall.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D /usr/share/osm-devops -t $DOCKER_TAG "$@"
1489      else
1490         /usr/share/osm-devops/installers/charmed_install.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D /usr/share/osm-devops -t $DOCKER_TAG "$@"
1491      fi
1492
1493      echo "Your installation is now complete, follow these steps for configuring the osmclient:"
1494      echo
1495      echo "1. Get the NBI IP with the following command:"
1496      echo
1497      echo "juju status --format yaml | yq r - applications.nbi-k8s.address"
1498      echo
1499      echo "2. Create the OSM_HOSTNAME environment variable with the NBI IP"
1500      echo
1501      echo "export OSM_HOSTNAME=<NBI-IP>"
1502      echo
1503      echo "3. Add the previous command to your .bashrc for other Shell sessions"
1504      echo
1505      echo "export OSM_HOSTNAME=<previous-IP> >> ~/.bashrc"
1506      echo
1507      echo "DONE"
1508
1509      exit 0
1510 fi
1511
1512 # if develop, we force master
1513 [ -z "$COMMIT_ID" ] && [ -n "$DEVELOP" ] && COMMIT_ID="master"
1514
1515 need_packages="git wget curl tar"
1516 echo -e "Checking required packages: $need_packages"
1517 dpkg -l $need_packages &>/dev/null \
1518   || ! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1519   || sudo apt-get update \
1520   || FATAL "failed to run apt-get update"
1521 dpkg -l $need_packages &>/dev/null \
1522   || ! echo -e "Installing $need_packages requires root privileges." \
1523   || sudo apt-get install -y $need_packages \
1524   || FATAL "failed to install $need_packages"
1525 sudo snap install jq
1526 if [ -z "$OSM_DEVOPS" ]; then
1527     if [ -n "$TEST_INSTALLER" ]; then
1528         echo -e "\nUsing local devops repo for OSM installation"
1529         OSM_DEVOPS="$(dirname $(realpath $(dirname $0)))"
1530     else
1531         echo -e "\nCreating temporary dir for OSM installation"
1532         OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")"
1533         trap 'rm -rf "$OSM_DEVOPS"' EXIT
1534
1535         git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS
1536
1537         if [ -z "$COMMIT_ID" ]; then
1538             echo -e "\nGuessing the current stable release"
1539             LATEST_STABLE_DEVOPS=`git -C $OSM_DEVOPS tag -l v[0-9].* | sort -V | tail -n1`
1540             [ -z "$LATEST_STABLE_DEVOPS" ] && echo "Could not find the current latest stable release" && exit 0
1541
1542             echo "Latest tag in devops repo: $LATEST_STABLE_DEVOPS"
1543             COMMIT_ID="tags/$LATEST_STABLE_DEVOPS"
1544         else
1545             echo -e "\nDEVOPS Using commit $COMMIT_ID"
1546         fi
1547         git -C $OSM_DEVOPS checkout $COMMIT_ID
1548     fi
1549 fi
1550
1551 . $OSM_DEVOPS/common/all_funcs
1552
1553 [ -n "$INSTALL_LIGHTWEIGHT" ] && [ -n "$UNINSTALL" ] && uninstall_lightweight && echo -e "\nDONE" && exit 0
1554 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_ELK" ] && deploy_elk
1555 #[ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_PERFMON" ] && deploy_perfmon
1556 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_VIMEMU" ] && install_vimemu
1557 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
1558 [ -n "$INSTALL_ONLY" ] && echo -e "\nDONE" && exit 0
1559
1560 #Installation starts here
1561 wget -q -O- https://osm-download.etsi.org/ftp/osm-7.0-seven/README.txt &> /dev/null
1562 track start
1563
1564 [ -n "$INSTALL_LIGHTWEIGHT" ] && install_lightweight && echo -e "\nDONE" && exit 0
1565 echo -e "\nInstalling OSM from refspec: $COMMIT_ID"
1566 if [ -n "$INSTALL_FROM_SOURCE" ] && [ -z "$ASSUME_YES" ]; then
1567     ! ask_user "The installation will take about 75-90 minutes. Continue (Y/n)? " y && echo "Cancelled!" && exit 1
1568 fi
1569
1570 echo -e "Checking required packages: lxd"
1571 lxd --version &>/dev/null || FATAL "lxd not present, exiting."
1572 [ -n "$INSTALL_LXD" ] && echo -e "\nInstalling and configuring lxd" && install_lxd
1573
1574 # use local devops for containers
1575 export OSM_USE_LOCAL_DEVOPS=true
1576
1577 #Install osmclient
1578
1579 #Install vim-emu (optional)
1580 [ -n "$INSTALL_VIMEMU" ] && install_docker_ce && install_vimemu
1581
1582 wget -q -O- https://osm-download.etsi.org/ftp/osm-7.0-seven/README2.txt &> /dev/null
1583 track end
1584 echo -e "\nDONE"
1585
1586