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