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