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