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 }
 467
 468 function juju_createcontroller_k8s(){
 469     cat $HOME/.kube/config | juju add-k8s $OSM_VCA_K8S_CLOUDNAME --client
 470     juju bootstrap $OSM_VCA_K8S_CLOUDNAME $OSM_STACK_NAME  \
 471             --config controller-service-type=loadbalancer \
 472             --agent-version=$JUJU_AGENT_VERSION
 473 }
 474
 475
 476 function juju_addlxd_cloud(){
 477     mkdir -p /tmp/.osm
 478     OSM_VCA_CLOUDNAME="lxd-cloud"
 479     LXDENDPOINT=$DEFAULT_IP
 480     LXD_CLOUD=/tmp/.osm/lxd-cloud.yaml
 481     LXD_CREDENTIALS=/tmp/.osm/lxd-credentials.yaml
 482
 483     cat << EOF > $LXD_CLOUD
 484 clouds:
 485   $OSM_VCA_CLOUDNAME:
 486     type: lxd
 487     auth-types: [certificate]
 488     endpoint: "https://$LXDENDPOINT:8443"
 489     config:
 490       ssl-hostname-verification: false
 491 EOF
 492     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"
 493     local server_cert=`cat /var/snap/lxd/common/lxd/server.crt | sed 's/^/        /'`
 494     local client_cert=`cat /tmp/.osm/client.crt | sed 's/^/        /'`
 495     local client_key=`cat /tmp/.osm/client.key | sed 's/^/        /'`
 496
 497     cat << EOF > $LXD_CREDENTIALS
 498 credentials:
 499   $OSM_VCA_CLOUDNAME:
 500     lxd-cloud:
 501       auth-type: certificate
 502       server-cert: |
 503 $server_cert
 504       client-cert: |
 505 $client_cert
 506       client-key: |
 507 $client_key
 508 EOF
 509     lxc config trust add local: /tmp/.osm/client.crt
 510     juju add-cloud -c $OSM_STACK_NAME $OSM_VCA_CLOUDNAME $LXD_CLOUD --force
 511     juju add-credential -c $OSM_STACK_NAME $OSM_VCA_CLOUDNAME -f $LXD_CREDENTIALS
 512     sg lxd -c "lxd waitready"
 513     juju controller-config features=[k8s-operators]
 514 }
 515
 516
 517 function juju_createproxy() {
 518     check_install_iptables_persistent
 519
 520     if ! sudo iptables -t nat -C PREROUTING -p tcp -m tcp -d $DEFAULT_IP --dport 17070 -j DNAT --to-destination $OSM_VCA_HOST; then
 521         sudo iptables -t nat -A PREROUTING -p tcp -m tcp -d $DEFAULT_IP --dport 17070 -j DNAT --to-destination $OSM_VCA_HOST
 522         sudo netfilter-persistent save
 523     fi
 524 }
 525
 526 function docker_login() {
 527     echo "Docker login"
 528     sg docker -c "docker login -u ${DOCKER_REGISTRY_USER} -p ${DOCKER_REGISTRY_PASSWORD}"
 529 }
 530
 531 function generate_docker_images() {
 532     echo "Pulling and generating docker images"
 533     [ -n "${DOCKER_REGISTRY_URL}" ] && docker_login
 534
 535     echo "Pulling docker images"
 536
 537     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q KAFKA ; then
 538         sg docker -c "docker pull wurstmeister/zookeeper" || FATAL "cannot get zookeeper docker image"
 539         sg docker -c "docker pull wurstmeister/kafka:${KAFKA_TAG}" || FATAL "cannot get kafka docker image"
 540     fi
 541
 542     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q MONGO ; then
 543         sg docker -c "docker pull mongo" || FATAL "cannot get mongo docker image"
 544     fi
 545
 546     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS ; then
 547         sg docker -c "docker pull prom/prometheus:${PROMETHEUS_TAG}" || FATAL "cannot get prometheus docker image"
 548     fi
 549
 550     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS-CADVISOR ; then
 551         sg docker -c "docker pull google/cadvisor:${PROMETHEUS_CADVISOR_TAG}" || FATAL "cannot get prometheus cadvisor docker image"
 552     fi
 553
 554     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q GRAFANA ; then
 555         sg docker -c "docker pull grafana/grafana:${GRAFANA_TAG}" || FATAL "cannot get grafana docker image"
 556     fi
 557
 558     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q NBI || echo $TO_REBUILD | grep -q KEYSTONE-DB ; then
 559         sg docker -c "docker pull mariadb:${KEYSTONEDB_TAG}" || FATAL "cannot get keystone-db docker image"
 560     fi
 561
 562     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q RO ; then
 563         sg docker -c "docker pull mysql:5" || FATAL "cannot get mysql docker image"
 564     fi
 565
 566     if [ -n "$PULL_IMAGES" ]; then
 567         echo "Pulling OSM docker images"
 568         for module in MON POL NBI KEYSTONE RO LCM NG-UI PLA osmclient; do
 569             module_lower=${module,,}
 570             if [ $module == "PLA" -a ! -n "$INSTALL_PLA" ]; then
 571                 continue
 572             fi
 573             module_tag="${OSM_DOCKER_TAG}"
 574             if [ -n "${MODULE_DOCKER_TAG}" ] && echo $TO_REBUILD | grep -q $module ; then
 575                 module_tag="${MODULE_DOCKER_TAG}"
 576             fi
 577             echo "Pulling ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module_lower}:${module_tag} docker image"
 578             sg docker -c "docker pull ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module_lower}:${module_tag}" || FATAL "cannot pull $module docker image"
 579         done
 580     else
 581         _build_from=$COMMIT_ID
 582         [ -z "$_build_from" ] && _build_from="latest"
 583         echo "OSM Docker images generated from $_build_from"
 584
 585         for module in MON POL NBI KEYSTONE RO LCM NG-UI PLA; do
 586             if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q ${module} ; then
 587                 module_lower=${module,,}
 588                 if [ $module == "PLA" -a ! -n "$INSTALL_PLA" ]; then
 589                     continue
 590                 fi
 591                 git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/$module
 592                 git -C ${LWTEMPDIR}/${module} checkout ${COMMIT_ID}
 593                 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"
 594             fi
 595         done
 596         if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q osmclient; then
 597             BUILD_ARGS+=(--build-arg REPOSITORY="$REPOSITORY")
 598             BUILD_ARGS+=(--build-arg RELEASE="$RELEASE")
 599             BUILD_ARGS+=(--build-arg REPOSITORY_KEY="$REPOSITORY_KEY")
 600             BUILD_ARGS+=(--build-arg REPOSITORY_BASE="$REPOSITORY_BASE")
 601             sg docker -c "docker build -t ${DOCKER_USER}/osmclient ${BUILD_ARGS[@]} -f $OSM_DEVOPS/docker/osmclient ."
 602         fi
 603         echo "Finished generation of docker images"
 604     fi
 605
 606     echo "Finished pulling and generating docker images"
 607 }
 608
 609 function cmp_overwrite() {
 610     file1="$1"
 611     file2="$2"
 612     if ! $(cmp "${file1}" "${file2}" >/dev/null 2>&1); then
 613         if [ -f "${file2}" ]; then
 614             ask_user "The file ${file2} already exists. Overwrite (y/N)? " n && cp -b ${file1} ${file2}
 615         else
 616             cp -b ${file1} ${file2}
 617         fi
 618     fi
 619 }
 620
 621 function generate_docker_compose_files() {
 622     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/docker-compose.yaml $OSM_DOCKER_WORK_DIR/docker-compose.yaml
 623     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/docker-compose-ngui.yaml $OSM_DOCKER_WORK_DIR/docker-compose-ui.yaml
 624     if [ -n "$INSTALL_PLA" ]; then
 625         $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/osm_pla/docker-compose.yaml $OSM_DOCKER_WORK_DIR/osm_pla/docker-compose.yaml
 626     fi
 627 }
 628
 629 function generate_k8s_manifest_files() {
 630     #Kubernetes resources
 631     $WORKDIR_SUDO cp -bR ${OSM_DEVOPS}/installers/docker/osm_pods $OSM_DOCKER_WORK_DIR
 632     $WORKDIR_SUDO rm -f $OSM_K8S_WORK_DIR/mongo.yaml
 633 }
 634
 635 function generate_prometheus_grafana_files() {
 636     [ -n "$KUBERNETES" ] && return
 637     # Prometheus files
 638     $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/prometheus
 639     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/prometheus/prometheus.yml $OSM_DOCKER_WORK_DIR/prometheus/prometheus.yml
 640
 641     # Grafana files
 642     $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/grafana
 643     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/dashboards-osm.yml $OSM_DOCKER_WORK_DIR/grafana/dashboards-osm.yml
 644     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/datasource-prometheus.yml $OSM_DOCKER_WORK_DIR/grafana/datasource-prometheus.yml
 645     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/osm-sample-dashboard.json $OSM_DOCKER_WORK_DIR/grafana/osm-sample-dashboard.json
 646     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/grafana/osm-system-dashboard.json $OSM_DOCKER_WORK_DIR/grafana/osm-system-dashboard.json
 647
 648     # Prometheus Exporters files
 649     $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/prometheus_exporters
 650     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/prometheus_exporters/node_exporter.service $OSM_DOCKER_WORK_DIR/prometheus_exporters/node_exporter.service
 651 }
 652
 653 function generate_docker_env_files() {
 654     echo "Doing a backup of existing env files"
 655     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/keystone-db.env{,~}
 656     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/keystone.env{,~}
 657     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/lcm.env{,~}
 658     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/mon.env{,~}
 659     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/nbi.env{,~}
 660     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/pol.env{,~}
 661     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/ro-db.env{,~}
 662     $WORKDIR_SUDO cp $OSM_DOCKER_WORK_DIR/ro.env{,~}
 663
 664     echo "Generating docker env files"
 665     # LCM
 666     if [ ! -f $OSM_DOCKER_WORK_DIR/lcm.env ]; then
 667         echo "OSMLCM_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 668     fi
 669
 670     if ! grep -Fq "OSMLCM_VCA_HOST" $OSM_DOCKER_WORK_DIR/lcm.env; then
 671         echo "OSMLCM_VCA_HOST=${OSM_VCA_HOST}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 672     else
 673         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_HOST.*|OSMLCM_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/lcm.env
 674     fi
 675
 676     if ! grep -Fq "OSMLCM_VCA_SECRET" $OSM_DOCKER_WORK_DIR/lcm.env; then
 677         echo "OSMLCM_VCA_SECRET=${OSM_VCA_SECRET}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 678     else
 679         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_SECRET.*|OSMLCM_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/lcm.env
 680     fi
 681
 682     if ! grep -Fq "OSMLCM_VCA_PUBKEY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 683         echo "OSMLCM_VCA_PUBKEY=${OSM_VCA_PUBKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 684     else
 685         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_PUBKEY.*|OSMLCM_VCA_PUBKEY=${OSM_VCA_PUBKEY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 686     fi
 687
 688     if ! grep -Fq "OSMLCM_VCA_CACERT" $OSM_DOCKER_WORK_DIR/lcm.env; then
 689         echo "OSMLCM_VCA_CACERT=${OSM_VCA_CACERT}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 690     else
 691         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_CACERT.*|OSMLCM_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 692     fi
 693
 694     if [ -n "$OSM_VCA_APIPROXY" ]; then
 695         if ! grep -Fq "OSMLCM_VCA_APIPROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 696             echo "OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 697         else
 698             $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_APIPROXY.*|OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 699         fi
 700     fi
 701
 702     if ! grep -Fq "OSMLCM_VCA_ENABLEOSUPGRADE" $OSM_DOCKER_WORK_DIR/lcm.env; then
 703         echo "# OSMLCM_VCA_ENABLEOSUPGRADE=false" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 704     fi
 705
 706     if ! grep -Fq "OSMLCM_VCA_APTMIRROR" $OSM_DOCKER_WORK_DIR/lcm.env; then
 707         echo "# OSMLCM_VCA_APTMIRROR=http://archive.ubuntu.com/ubuntu/" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 708     fi
 709
 710     if ! grep -Fq "OSMLCM_VCA_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env; then
 711         echo "OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 712     else
 713         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_CLOUD.*|OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 714     fi
 715
 716     if ! grep -Fq "OSMLCM_VCA_K8S_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env; then
 717         echo "OSMLCM_VCA_K8S_CLOUD=${OSM_VCA_K8S_CLOUDNAME}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 718     else
 719         $WORKDIR_SUDO sed -i "s|OSMLCM_VCA_K8S_CLOUD.*|OSMLCM_VCA_K8S_CLOUD=${OSM_VCA_K8S_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 720     fi
 721
 722     # RO
 723     MYSQL_ROOT_PASSWORD=$(generate_secret)
 724     if [ ! -f $OSM_DOCKER_WORK_DIR/ro-db.env ]; then
 725         echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/ro-db.env
 726     fi
 727     if [ ! -f $OSM_DOCKER_WORK_DIR/ro.env ]; then
 728         echo "RO_DB_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/ro.env
 729     fi
 730     if ! grep -Fq "OSMRO_DATABASE_COMMONKEY" $OSM_DOCKER_WORK_DIR/ro.env; then
 731         echo "OSMRO_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/ro.env
 732     fi
 733
 734     # Keystone
 735     KEYSTONE_DB_PASSWORD=$(generate_secret)
 736     SERVICE_PASSWORD=$(generate_secret)
 737     if [ ! -f $OSM_DOCKER_WORK_DIR/keystone-db.env ]; then
 738         echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/keystone-db.env
 739     fi
 740     if [ ! -f $OSM_DOCKER_WORK_DIR/keystone.env ]; then
 741         echo "ROOT_DB_PASSWORD=${MYSQL_ROOT_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/keystone.env
 742         echo "KEYSTONE_DB_PASSWORD=${KEYSTONE_DB_PASSWORD}" |$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/keystone.env
 743         echo "SERVICE_PASSWORD=${SERVICE_PASSWORD}" |$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/keystone.env
 744     fi
 745
 746     # NBI
 747     if [ ! -f $OSM_DOCKER_WORK_DIR/nbi.env ]; then
 748         echo "OSMNBI_AUTHENTICATION_SERVICE_PASSWORD=${SERVICE_PASSWORD}" |$WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/nbi.env
 749         echo "OSMNBI_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/nbi.env
 750     fi
 751
 752     # MON
 753     if [ ! -f $OSM_DOCKER_WORK_DIR/mon.env ]; then
 754         echo "OSMMON_KEYSTONE_SERVICE_PASSWORD=${SERVICE_PASSWORD}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 755         echo "OSMMON_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 756         echo "OSMMON_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/mon" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 757     fi
 758
 759     if ! grep -Fq "OS_NOTIFIER_URI" $OSM_DOCKER_WORK_DIR/mon.env; then
 760         echo "OS_NOTIFIER_URI=http://${DEFAULT_IP}:8662" |$WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 761     else
 762         $WORKDIR_SUDO sed -i "s|OS_NOTIFIER_URI.*|OS_NOTIFIER_URI=http://$DEFAULT_IP:8662|g" $OSM_DOCKER_WORK_DIR/mon.env
 763     fi
 764
 765     if ! grep -Fq "OSMMON_VCA_HOST" $OSM_DOCKER_WORK_DIR/mon.env; then
 766         echo "OSMMON_VCA_HOST=${OSM_VCA_HOST}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 767     else
 768         $WORKDIR_SUDO sed -i "s|OSMMON_VCA_HOST.*|OSMMON_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/mon.env
 769     fi
 770
 771     if ! grep -Fq "OSMMON_VCA_SECRET" $OSM_DOCKER_WORK_DIR/mon.env; then
 772         echo "OSMMON_VCA_SECRET=${OSM_VCA_SECRET}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 773     else
 774         $WORKDIR_SUDO sed -i "s|OSMMON_VCA_SECRET.*|OSMMON_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/mon.env
 775     fi
 776
 777     if ! grep -Fq "OSMMON_VCA_CACERT" $OSM_DOCKER_WORK_DIR/mon.env; then
 778         echo "OSMMON_VCA_CACERT=${OSM_VCA_CACERT}" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/mon.env
 779     else
 780         $WORKDIR_SUDO sed -i "s|OSMMON_VCA_CACERT.*|OSMMON_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/mon.env
 781     fi
 782
 783
 784     # POL
 785     if [ ! -f $OSM_DOCKER_WORK_DIR/pol.env ]; then
 786         echo "OSMPOL_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/pol" | $WORKDIR_SUDO tee -a $OSM_DOCKER_WORK_DIR/pol.env
 787     fi
 788
 789     echo "Finished generation of docker env files"
 790 }
 791
 792 function generate_osmclient_script () {
 793     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
 794     $WORKDIR_SUDO chmod +x "$OSM_DOCKER_WORK_DIR/osm"
 795     echo "osmclient sidecar container can be found at: $OSM_DOCKER_WORK_DIR/osm"
 796 }
 797
 798 #installs kubernetes packages
 799 function install_kube() {
 800     sudo apt-get update && sudo apt-get install -y apt-transport-https
 801     curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
 802     sudo add-apt-repository "deb https://apt.kubernetes.io/ kubernetes-xenial main"
 803     sudo apt-get update
 804     echo "Installing Kubernetes Packages ..."
 805     sudo apt-get install -y kubelet=1.15.0-00 kubeadm=1.15.0-00 kubectl=1.15.0-00
 806     sudo apt-mark hold kubelet kubeadm kubectl
 807 }
 808
 809 #initializes kubernetes control plane
 810 function init_kubeadm() {
 811     sudo swapoff -a
 812     sudo sed -i.bak '/.*none.*swap/s/^\(.*\)$/#\1/g' /etc/fstab
 813     sudo kubeadm init --config $1
 814     sleep 5
 815 }
 816
 817 function kube_config_dir() {
 818     [ ! -d $K8S_MANIFEST_DIR ] && FATAL "Cannot Install Kubernetes"
 819     mkdir -p $HOME/.kube
 820     sudo cp /etc/kubernetes/admin.conf $HOME/.kube/config
 821     sudo chown $(id -u):$(id -g) $HOME/.kube/config
 822 }
 823
 824 function install_k8s_storageclass() {
 825     echo "Installing OpenEBS"
 826     kubectl create ns openebs
 827     helm repo add openebs https://openebs.github.io/charts
 828     helm repo update
 829     helm install --namespace openebs openebs openebs/openebs --version 1.12.0
 830     helm ls -n openebs
 831     local storageclass_timeout=400
 832     local counter=0
 833     local storageclass_ready=""
 834     echo "Waiting for storageclass"
 835     while (( counter < storageclass_timeout ))
 836     do
 837         kubectl get storageclass openebs-hostpath &> /dev/null
 838
 839         if [ $? -eq 0 ] ; then
 840             echo "Storageclass available"
 841             storageclass_ready="y"
 842             break
 843         else
 844             counter=$((counter + 15))
 845             sleep 15
 846         fi
 847     done
 848     [ -n "$storageclass_ready" ] || FATAL "Storageclass not ready after $storageclass_timeout seconds. Cannot install openebs"
 849     kubectl patch storageclass openebs-hostpath -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
 850 }
 851
 852 function install_k8s_metallb() {
 853     METALLB_IP_RANGE=$DEFAULT_IP-$DEFAULT_IP
 854     cat ${OSM_DEVOPS}/installers/k8s/metallb/metallb.yaml | kubectl apply -f -
 855     echo "apiVersion: v1
 856 kind: ConfigMap
 857 metadata:
 858   namespace: metallb-system
 859   name: config
 860 data:
 861   config: |
 862     address-pools:
 863     - name: default
 864       protocol: layer2
 865       addresses:
 866       - $METALLB_IP_RANGE" | kubectl apply -f -
 867 }
 868 #deploys flannel as daemonsets
 869 function deploy_cni_provider() {
 870     CNI_DIR="$(mktemp -d -q --tmpdir "flannel.XXXXXX")"
 871     trap 'rm -rf "${CNI_DIR}"' EXIT
 872     wget -q https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml -P $CNI_DIR
 873     kubectl apply -f $CNI_DIR
 874     [ $? -ne 0 ] && FATAL "Cannot Install Flannel"
 875 }
 876
 877 #creates secrets from env files which will be used by containers
 878 function kube_secrets(){
 879     kubectl create ns $OSM_STACK_NAME
 880     kubectl create secret generic lcm-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/lcm.env
 881     kubectl create secret generic mon-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/mon.env
 882     kubectl create secret generic nbi-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/nbi.env
 883     kubectl create secret generic ro-db-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ro-db.env
 884     kubectl create secret generic ro-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/ro.env
 885     kubectl create secret generic keystone-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/keystone.env
 886     kubectl create secret generic pol-secret -n $OSM_STACK_NAME --from-env-file=$OSM_DOCKER_WORK_DIR/pol.env
 887 }
 888
 889 #taints K8s master node
 890 function taint_master_node() {
 891     K8S_MASTER=$(kubectl get nodes | awk '$3~/master/'| awk '{print $1}')
 892     kubectl taint node $K8S_MASTER node-role.kubernetes.io/master:NoSchedule-
 893     sleep 5
 894 }
 895
 896 #deploys osm pods and services
 897 function deploy_osm_services() {
 898     kubectl apply -n $OSM_STACK_NAME -f $OSM_K8S_WORK_DIR
 899 }
 900
 901 #deploy charmed services
 902 function deploy_charmed_services() {
 903     juju add-model $OSM_STACK_NAME $OSM_VCA_K8S_CLOUDNAME
 904     # deploy mongodb charm
 905     namespace=$OSM_STACK_NAME
 906     juju deploy cs:~charmed-osm/mongodb-k8s \
 907         --config enable-sidecar=true \
 908         --config replica-set=rs0 \
 909         --config namespace=$namespace \
 910         -m $namespace
 911 }
 912
 913 function deploy_osm_pla_service() {
 914     # corresponding to namespace_vol
 915     $WORKDIR_SUDO  sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_DOCKER_WORK_DIR/osm_pla/pla.yaml
 916     # corresponding to deploy_osm_services
 917     kubectl apply -n $OSM_STACK_NAME -f $OSM_DOCKER_WORK_DIR/osm_pla
 918 }
 919
 920 #Install Helm v3
 921 function install_helm() {
 922     helm > /dev/null 2>&1
 923     if [ $? != 0 ] ; then
 924         # Helm is not installed. Install helm
 925         echo "Helm is not installed, installing ..."
 926         curl https://get.helm.sh/helm-v3.6.3-linux-amd64.tar.gz --output helm-v3.6.3.tar.gz
 927         tar -zxvf helm-v3.6.3.tar.gz
 928         sudo mv linux-amd64/helm /usr/local/bin/helm
 929         rm -r linux-amd64
 930         rm helm-v3.6.3.tar.gz
 931         helm repo add stable https://charts.helm.sh/stable
 932         helm repo update
 933     fi
 934 }
 935
 936 function parse_yaml() {
 937     TAG=$1
 938     shift
 939     services=$@
 940     for module in $services; do
 941         if [ "$module" == "pla" ]; then
 942             if [ -n "$INSTALL_PLA" ]; then
 943                 echo "Updating K8s manifest file from opensourcemano\/${module}:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/${module}:${TAG}"
 944                 $WORKDIR_SUDO sed -i "s#opensourcemano/pla:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/pla:${TAG}#g" ${OSM_DOCKER_WORK_DIR}/osm_pla/pla.yaml
 945             fi
 946         else
 947             echo "Updating K8s manifest file from opensourcemano\/${module}:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/${module}:${TAG}"
 948             $WORKDIR_SUDO sed -i "s#opensourcemano/${module}:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module}:${TAG}#g" ${OSM_K8S_WORK_DIR}/${module}.yaml
 949         fi
 950     done
 951 }
 952
 953 function update_manifest_files() {
 954     osm_services="nbi lcm ro pol mon ng-ui keystone pla"
 955     list_of_services=""
 956     for module in $osm_services; do
 957         module_upper="${module^^}"
 958         if ! echo $TO_REBUILD | grep -q $module_upper ; then
 959             list_of_services="$list_of_services $module"
 960         fi
 961     done
 962     if [ ! "$OSM_DOCKER_TAG" == "10" ]; then
 963         parse_yaml $OSM_DOCKER_TAG $list_of_services
 964     fi
 965     if [ -n "$MODULE_DOCKER_TAG" ]; then
 966         parse_yaml $MODULE_DOCKER_TAG $list_of_services_to_rebuild
 967     fi
 968 }
 969
 970 function namespace_vol() {
 971     osm_services="nbi lcm ro pol mon kafka mysql prometheus"
 972     for osm in $osm_services; do
 973         $WORKDIR_SUDO  sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_K8S_WORK_DIR/$osm.yaml
 974     done
 975 }
 976
 977 function init_docker_swarm() {
 978     if [ "${DEFAULT_MTU}" != "1500" ]; then
 979       DOCKER_NETS=`sg docker -c "docker network list" | awk '{print $2}' | egrep -v "^ID$" | paste -d " " -s`
 980       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";}'`
 981       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"
 982     fi
 983     sg docker -c "docker swarm init --advertise-addr ${DEFAULT_IP}"
 984     return 0
 985 }
 986
 987 function create_docker_network() {
 988     echo "creating network"
 989     sg docker -c "docker network create --driver=overlay --attachable --opt com.docker.network.driver.mtu=${DEFAULT_MTU} net${OSM_STACK_NAME}"
 990     echo "creating network DONE"
 991 }
 992
 993 function deploy_lightweight() {
 994
 995     echo "Deploying lightweight build"
 996     OSM_NBI_PORT=9999
 997     OSM_RO_PORT=9090
 998     OSM_KEYSTONE_PORT=5000
 999     OSM_UI_PORT=80
1000     OSM_MON_PORT=8662
1001     OSM_PROM_PORT=9090
1002     OSM_PROM_CADVISOR_PORT=8080
1003     OSM_PROM_HOSTPORT=9091
1004     OSM_GRAFANA_PORT=3000
1005     [ -n "$INSTALL_ELK" ] && OSM_ELK_PORT=5601
1006     #[ -n "$INSTALL_PERFMON" ] && OSM_PM_PORT=3000
1007
1008     if [ -n "$NO_HOST_PORTS" ]; then
1009         OSM_PORTS+=(OSM_NBI_PORTS=$OSM_NBI_PORT)
1010         OSM_PORTS+=(OSM_RO_PORTS=$OSM_RO_PORT)
1011         OSM_PORTS+=(OSM_KEYSTONE_PORTS=$OSM_KEYSTONE_PORT)
1012         OSM_PORTS+=(OSM_UI_PORTS=$OSM_UI_PORT)
1013         OSM_PORTS+=(OSM_MON_PORTS=$OSM_MON_PORT)
1014         OSM_PORTS+=(OSM_PROM_PORTS=$OSM_PROM_PORT)
1015         OSM_PORTS+=(OSM_PROM_CADVISOR_PORTS=$OSM_PROM_CADVISOR_PORT)
1016         OSM_PORTS+=(OSM_GRAFANA_PORTS=$OSM_GRAFANA_PORT)
1017         #[ -n "$INSTALL_PERFMON" ] && OSM_PORTS+=(OSM_PM_PORTS=$OSM_PM_PORT)
1018         [ -n "$INSTALL_ELK" ] && OSM_PORTS+=(OSM_ELK_PORTS=$OSM_ELK_PORT)
1019     else
1020         OSM_PORTS+=(OSM_NBI_PORTS=$OSM_NBI_PORT:$OSM_NBI_PORT)
1021         OSM_PORTS+=(OSM_RO_PORTS=$OSM_RO_PORT:$OSM_RO_PORT)
1022         OSM_PORTS+=(OSM_KEYSTONE_PORTS=$OSM_KEYSTONE_PORT:$OSM_KEYSTONE_PORT)
1023         OSM_PORTS+=(OSM_UI_PORTS=$OSM_UI_PORT:$OSM_UI_PORT)
1024         OSM_PORTS+=(OSM_MON_PORTS=$OSM_MON_PORT:$OSM_MON_PORT)
1025         OSM_PORTS+=(OSM_PROM_PORTS=$OSM_PROM_HOSTPORT:$OSM_PROM_PORT)
1026         OSM_PORTS+=(OSM_PROM_CADVISOR_PORTS=$OSM_PROM_CADVISOR_PORT:$OSM_PROM_CADVISOR_PORT)
1027         OSM_PORTS+=(OSM_GRAFANA_PORTS=$OSM_GRAFANA_PORT:$OSM_GRAFANA_PORT)
1028         #[ -n "$INSTALL_PERFMON" ] && OSM_PORTS+=(OSM_PM_PORTS=$OSM_PM_PORT:$OSM_PM_PORT)
1029         [ -n "$INSTALL_ELK" ] && OSM_PORTS+=(OSM_ELK_PORTS=$OSM_ELK_PORT:$OSM_ELK_PORT)
1030     fi
1031     echo "export ${OSM_PORTS[@]}" | $WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/osm_ports.sh
1032     echo "export OSM_NETWORK=net${OSM_STACK_NAME}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1033     echo "export TAG=${OSM_DOCKER_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1034     echo "export DOCKER_USER=${DOCKER_USER}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1035     echo "export KAFKA_TAG=${KAFKA_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1036     echo "export PROMETHEUS_TAG=${PROMETHEUS_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1037     echo "export KEYSTONEDB_TAG=${KEYSTONEDB_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1038     echo "export PROMETHEUS_CADVISOR_TAG=${PROMETHEUS_CADVISOR_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1039     echo "export GRAFANA_TAG=${GRAFANA_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1040
1041     pushd $OSM_DOCKER_WORK_DIR
1042     if [ -n "$INSTALL_PLA" ]; then
1043         track deploy_osm_pla
1044         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"
1045     else
1046         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"
1047     fi
1048     popd
1049
1050     echo "Finished deployment of lightweight build"
1051 }
1052
1053 function deploy_elk() {
1054     echo "Pulling docker images for ELK"
1055     sg docker -c "docker pull docker.elastic.co/elasticsearch/elasticsearch-oss:${ELASTIC_VERSION}" || FATAL "cannot get elasticsearch docker image"
1056     sg docker -c "docker pull docker.elastic.co/beats/metricbeat:${ELASTIC_VERSION}" || FATAL "cannot get metricbeat docker image"
1057     sg docker -c "docker pull docker.elastic.co/beats/filebeat:${ELASTIC_VERSION}" || FATAL "cannot get filebeat docker image"
1058     sg docker -c "docker pull docker.elastic.co/kibana/kibana-oss:${ELASTIC_VERSION}" || FATAL "cannot get kibana docker image"
1059     sg docker -c "docker pull bobrik/curator:${ELASTIC_CURATOR_VERSION}" || FATAL "cannot get curator docker image"
1060     echo "Finished pulling elk docker images"
1061     $WORKDIR_SUDO mkdir -p "$OSM_DOCKER_WORK_DIR/osm_elk"
1062     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/osm_elk/* $OSM_DOCKER_WORK_DIR/osm_elk
1063     remove_stack osm_elk
1064     echo "Deploying ELK stack"
1065     sg docker -c "OSM_NETWORK=net${OSM_STACK_NAME} docker stack deploy -c $OSM_DOCKER_WORK_DIR/osm_elk/docker-compose.yml osm_elk"
1066     echo "Waiting for ELK stack to be up and running"
1067     time=0
1068     step=5
1069     timelength=40
1070     elk_is_up=1
1071     while [ $time -le $timelength ]; do
1072         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
1073             elk_is_up=0
1074             break
1075         fi
1076         sleep $step
1077         time=$((time+step))
1078     done
1079     if [ $elk_is_up -eq 0 ]; then
1080         echo "ELK is up and running. Trying to create index pattern..."
1081         #Create index pattern
1082         curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1083           "http://127.0.0.1:5601/api/saved_objects/index-pattern/filebeat-*" \
1084           -d"{\"attributes\":{\"title\":\"filebeat-*\",\"timeFieldName\":\"@timestamp\"}}" 2>/dev/null
1085         #Make it the default index
1086         curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1087           "http://127.0.0.1:5601/api/kibana/settings/defaultIndex" \
1088           -d"{\"value\":\"filebeat-*\"}" 2>/dev/null
1089     else
1090         echo "Cannot connect to Kibana to create index pattern."
1091         echo "Once Kibana is running, you can use the following instructions to create index pattern:"
1092         echo 'curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1093           "http://127.0.0.1:5601/api/saved_objects/index-pattern/filebeat-*" \
1094           -d"{\"attributes\":{\"title\":\"filebeat-*\",\"timeFieldName\":\"@timestamp\"}}"'
1095         echo 'curl -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1096           "http://127.0.0.1:5601/api/kibana/settings/defaultIndex" \
1097           -d"{\"value\":\"filebeat-*\"}"'
1098     fi
1099     echo "Finished deployment of ELK stack"
1100     return 0
1101 }
1102
1103 function add_local_k8scluster() {
1104     /usr/bin/osm --all-projects vim-create \
1105       --name _system-osm-vim \
1106       --account_type dummy \
1107       --auth_url http://dummy \
1108       --user osm --password osm --tenant osm \
1109       --description "dummy" \
1110       --config '{management_network_name: mgmt}'
1111     /usr/bin/osm --all-projects k8scluster-add \
1112       --creds ${HOME}/.kube/config \
1113       --vim _system-osm-vim \
1114       --k8s-nets '{"net1": null}' \
1115       --version '1.15' \
1116       --description "OSM Internal Cluster" \
1117       _system-osm-k8s
1118 }
1119
1120 function install_lightweight() {
1121     track checkingroot
1122     [ "$USER" == "root" ] && FATAL "You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges."
1123     track noroot
1124
1125     if [ -n "$KUBERNETES" ]; then
1126         [ -z "$ASSUME_YES" ] && ! ask_user "The installation will do the following
1127         1. Install and configure LXD
1128         2. Install juju
1129         3. Install docker CE
1130         4. Disable swap space
1131         5. Install and initialize Kubernetes
1132         as pre-requirements.
1133         Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1
1134
1135     else
1136         [ -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
1137     fi
1138     track proceed
1139
1140     echo "Installing lightweight build of OSM"
1141     LWTEMPDIR="$(mktemp -d -q --tmpdir "installosmlight.XXXXXX")"
1142     trap 'rm -rf "${LWTEMPDIR}"' EXIT
1143     DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}')
1144     [ -z "$DEFAULT_IF" ] && DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
1145     [ -z "$DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0"
1146     DEFAULT_IP=`ip -o -4 a s ${DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]}'`
1147     [ -z "$DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route"
1148     DEFAULT_MTU=$(ip addr show ${DEFAULT_IF} | perl -ne 'if (/mtu\s(\d+)/) {print $1;}')
1149
1150     # if no host is passed in, we need to install lxd/juju, unless explicilty asked not to
1151     if [ -z "$OSM_VCA_HOST" ] && [ -z "$INSTALL_NOLXD" ] && [ -z "$LXD_CLOUD_FILE" ]; then
1152         need_packages_lw="snapd"
1153         echo -e "Checking required packages: $need_packages_lw"
1154         dpkg -l $need_packages_lw &>/dev/null \
1155           || ! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1156           || sudo apt-get update \
1157           || FATAL "failed to run apt-get update"
1158         dpkg -l $need_packages_lw &>/dev/null \
1159           || ! echo -e "Installing $need_packages_lw requires root privileges." \
1160           || sudo apt-get install -y $need_packages_lw \
1161           || FATAL "failed to install $need_packages_lw"
1162         install_lxd
1163     fi
1164
1165     track prereqok
1166
1167     [ -n "$INSTALL_NODOCKER" ] || (install_docker_ce && track docker_ce)
1168
1169     echo "Creating folders for installation"
1170     [ ! -d "$OSM_DOCKER_WORK_DIR" ] && $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR
1171     [ ! -d "$OSM_DOCKER_WORK_DIR/osm_pla" -a -n "$INSTALL_PLA" ] && $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/osm_pla
1172     [ -n "$KUBERNETES" ] && $WORKDIR_SUDO cp -b $OSM_DEVOPS/installers/docker/cluster-config.yaml $OSM_DOCKER_WORK_DIR/cluster-config.yaml
1173
1174     #Installs Kubernetes
1175     if [ -n "$KUBERNETES" ]; then
1176         install_kube
1177         track install_k8s
1178         init_kubeadm $OSM_DOCKER_WORK_DIR/cluster-config.yaml
1179         kube_config_dir
1180         track init_k8s
1181         if [ -n "$INSTALL_K8S_MONITOR" ]; then
1182             # uninstall OSM MONITORING
1183             uninstall_k8s_monitoring
1184             track uninstall_k8s_monitoring
1185         fi
1186         #remove old namespace
1187         remove_k8s_namespace $OSM_STACK_NAME
1188         deploy_cni_provider
1189         taint_master_node
1190         install_helm
1191         track install_helm
1192         install_k8s_storageclass
1193         track k8s_storageclass
1194         install_k8s_metallb
1195         track k8s_metallb
1196     else
1197         #install_docker_compose
1198         [ -n "$INSTALL_NODOCKER" ] || init_docker_swarm
1199         track docker_swarm
1200     fi
1201
1202     [ -z "$INSTALL_NOJUJU" ] && install_juju
1203     track juju_install
1204
1205     if [ -z "$OSM_VCA_HOST" ]; then
1206         if [ -z "$CONTROLLER_NAME" ]; then
1207
1208             if [ -n "$KUBERNETES" ]; then
1209                 juju_createcontroller_k8s
1210                 juju_addlxd_cloud
1211             else
1212                 if [ -n "$LXD_CLOUD_FILE" ]; then
1213                     [ -z "$LXD_CRED_FILE" ] && FATAL "The installer needs the LXD credential yaml if the LXD is external"
1214                     OSM_VCA_CLOUDNAME="lxd-cloud"
1215                     juju add-cloud $OSM_VCA_CLOUDNAME $LXD_CLOUD_FILE --force || juju update-cloud $OSM_VCA_CLOUDNAME --client -f $LXD_CLOUD_FILE
1216                     juju add-credential $OSM_VCA_CLOUDNAME -f $LXD_CRED_FILE || juju update-credential $OSM_VCA_CLOUDNAME lxd-cloud-creds -f $LXD_CRED_FILE
1217                 fi
1218                 juju_createcontroller
1219                 juju_createproxy
1220             fi
1221         else
1222             OSM_VCA_CLOUDNAME="lxd-cloud"
1223             if [ -n "$LXD_CLOUD_FILE" ]; then
1224                 [ -z "$LXD_CRED_FILE" ] && FATAL "The installer needs the LXD credential yaml if the LXD is external"
1225                 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
1226                 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
1227             else
1228                 mkdir -p ~/.osm
1229                 cat << EOF > ~/.osm/lxd-cloud.yaml
1230 clouds:
1231   lxd-cloud:
1232     type: lxd
1233     auth-types: [certificate]
1234     endpoint: "https://$DEFAULT_IP:8443"
1235     config:
1236       ssl-hostname-verification: false
1237 EOF
1238                 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"
1239                 local server_cert=`cat /var/snap/lxd/common/lxd/server.crt | sed 's/^/        /'`
1240                 local client_cert=`cat ~/.osm/client.crt | sed 's/^/        /'`
1241                 local client_key=`cat ~/.osm/client.key | sed 's/^/        /'`
1242                 cat << EOF > ~/.osm/lxd-credentials.yaml
1243 credentials:
1244   lxd-cloud:
1245     lxd-cloud:
1246       auth-type: certificate
1247       server-cert: |
1248 $server_cert
1249       client-cert: |
1250 $client_cert
1251       client-key: |
1252 $client_key
1253 EOF
1254                 lxc config trust add local: ~/.osm/client.crt
1255                 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
1256                 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
1257             fi
1258         fi
1259         [ -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}'`
1260         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`juju show-controller $CONTROLLER_NAME |grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
1261         [ -z "$OSM_VCA_HOST" ] && FATAL "Cannot obtain juju controller IP address"
1262     fi
1263     track juju_controller
1264
1265     if [ -z "$OSM_VCA_SECRET" ]; then
1266         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $OSM_STACK_NAME)
1267         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $CONTROLLER_NAME)
1268         [ -z "$OSM_VCA_SECRET" ] && FATAL "Cannot obtain juju secret"
1269     fi
1270     if [ -z "$OSM_VCA_PUBKEY" ]; then
1271         OSM_VCA_PUBKEY=$(cat $HOME/.local/share/juju/ssh/juju_id_rsa.pub)
1272         [ -z "$OSM_VCA_PUBKEY" ] && FATAL "Cannot obtain juju public key"
1273     fi
1274     if [ -z "$OSM_VCA_CACERT" ]; then
1275         [ -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)
1276         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $CONTROLLER_NAME '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
1277        [ -z "$OSM_VCA_CACERT" ] && FATAL "Cannot obtain juju CA certificate"
1278     fi
1279
1280     # Set OSM_VCA_APIPROXY only when it is not a k8s installation
1281     if [ -z "$KUBERNETES" ]; then
1282         if [ -z "$OSM_VCA_APIPROXY" ]; then
1283             OSM_VCA_APIPROXY=$DEFAULT_IP
1284             [ -z "$OSM_VCA_APIPROXY" ] && FATAL "Cannot obtain juju api proxy"
1285         fi
1286         juju_createproxy
1287     fi
1288     track juju
1289
1290     if [ -z "$OSM_DATABASE_COMMONKEY" ]; then
1291         OSM_DATABASE_COMMONKEY=$(generate_secret)
1292         [ -z "OSM_DATABASE_COMMONKEY" ] && FATAL "Cannot generate common db secret"
1293     fi
1294
1295     # Deploy OSM services
1296     [ -z "$DOCKER_NOBUILD" ] && generate_docker_images
1297     track docker_build
1298
1299     if [ -n "$KUBERNETES" ]; then
1300         generate_k8s_manifest_files
1301     else
1302         generate_docker_compose_files
1303     fi
1304     track manifest_files
1305     generate_prometheus_grafana_files
1306     generate_docker_env_files
1307     track env_files
1308
1309     if [ -n "$KUBERNETES" ]; then
1310         deploy_charmed_services
1311         kube_secrets
1312         update_manifest_files
1313         namespace_vol
1314         deploy_osm_services
1315         if [ -n "$INSTALL_PLA"]; then
1316             # optional PLA install
1317             deploy_osm_pla_service
1318             track deploy_osm_pla
1319         fi
1320         track deploy_osm_services_k8s
1321         if [ -n "$INSTALL_K8S_MONITOR" ]; then
1322             # install OSM MONITORING
1323             install_k8s_monitoring
1324             track install_k8s_monitoring
1325         fi
1326     else
1327         # remove old stack
1328         remove_stack $OSM_STACK_NAME
1329         create_docker_network
1330         deploy_lightweight
1331         generate_osmclient_script
1332         track docker_deploy
1333         install_prometheus_nodeexporter
1334         track nodeexporter
1335         [ -n "$INSTALL_VIMEMU" ] && install_vimemu && track vimemu
1336         [ -n "$INSTALL_ELK" ] && deploy_elk && track elk
1337     fi
1338
1339     [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
1340     track osmclient
1341
1342     echo -e "Checking OSM health state..."
1343     if [ -n "$KUBERNETES" ]; then
1344         $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_STACK_NAME} -k || \
1345         echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
1346         echo -e "Check OSM status with: kubectl -n ${OSM_STACK_NAME} get all" && \
1347         track osm_unhealthy
1348     else
1349         $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_STACK_NAME} || \
1350         echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
1351         echo -e "Check OSM status with: docker service ls; docker stack ps ${OSM_STACK_NAME}" && \
1352         track osm_unhealthy
1353     fi
1354     track after_healthcheck
1355
1356     [ -n "$KUBERNETES" ] && add_local_k8scluster
1357     track add_local_k8scluster
1358
1359     wget -q -O- https://osm-download.etsi.org/ftp/osm-10.0-ten/README2.txt &> /dev/null
1360     track end
1361     return 0
1362 }
1363
1364 function install_to_openstack() {
1365
1366     if [ -z "$2" ]; then
1367         FATAL "OpenStack installer requires a valid external network name"
1368     fi
1369
1370     # Install Pip for Python3
1371     $WORKDIR_SUDO apt install -y python3-pip python3-venv
1372     $WORKDIR_SUDO -H LC_ALL=C python3 -m pip install -U pip
1373
1374     # Create a venv to avoid conflicts with the host installation
1375     python3 -m venv $OPENSTACK_PYTHON_VENV
1376
1377     source $OPENSTACK_PYTHON_VENV/bin/activate
1378
1379     # Install Ansible, OpenStack client and SDK, latest openstack version supported is Train
1380     python -m pip install -U wheel
1381     python -m pip install -U "python-openstackclient<=4.0.2" "openstacksdk>=0.12.0,<=0.36.2" "ansible>=2.10,<2.11"
1382
1383     # Install the Openstack cloud module (ansible>=2.10)
1384     ansible-galaxy collection install openstack.cloud
1385
1386     export ANSIBLE_CONFIG="$OSM_DEVOPS/installers/openstack/ansible.cfg"
1387
1388     OSM_INSTALLER_ARGS="${REPO_ARGS[@]}"
1389
1390     ANSIBLE_VARS="external_network_name=$2 setup_volume=$3 server_name=$OPENSTACK_VM_NAME"
1391
1392     if [ -n "$OPENSTACK_SSH_KEY_FILE" ]; then
1393         ANSIBLE_VARS+=" key_file=$OPENSTACK_SSH_KEY_FILE"
1394     fi
1395
1396     if [ -n "$OPENSTACK_USERDATA_FILE" ]; then
1397         ANSIBLE_VARS+=" userdata_file=$OPENSTACK_USERDATA_FILE"
1398     fi
1399
1400     # Execute the Ansible playbook based on openrc or clouds.yaml
1401     if [ -e "$1" ]; then
1402         . $1
1403         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
1404         $OSM_DEVOPS/installers/openstack/site.yml
1405     else
1406         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
1407         -e cloud_name=$1 $OSM_DEVOPS/installers/openstack/site.yml
1408     fi
1409
1410     # Exit from venv
1411     deactivate
1412
1413     return 0
1414 }
1415
1416 function install_vimemu() {
1417     echo "\nInstalling vim-emu"
1418     EMUTEMPDIR="$(mktemp -d -q --tmpdir "installosmvimemu.XXXXXX")"
1419     trap 'rm -rf "${EMUTEMPDIR}"' EXIT
1420     # install prerequisites (OVS is a must for the emulator to work)
1421     sudo apt-get install openvswitch-switch
1422     # clone vim-emu repository (attention: branch is currently master only)
1423     echo "Cloning vim-emu repository ..."
1424     git clone https://osm.etsi.org/gerrit/osm/vim-emu.git $EMUTEMPDIR
1425     # build vim-emu docker
1426     echo "Building vim-emu Docker container..."
1427
1428     sg docker -c "docker build -t vim-emu-img -f $EMUTEMPDIR/Dockerfile --no-cache $EMUTEMPDIR/" || FATAL "cannot build vim-emu-img docker image"
1429     # start vim-emu container as daemon
1430     echo "Starting vim-emu Docker container 'vim-emu' ..."
1431     if [ -n "$INSTALL_LIGHTWEIGHT" ]; then
1432         # in lightweight mode, the emulator needs to be attached to netOSM
1433         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"
1434     else
1435         # classic build mode
1436         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"
1437     fi
1438     echo "Waiting for 'vim-emu' container to start ..."
1439     sleep 5
1440     export VIMEMU_HOSTNAME=$(sg docker -c "docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' vim-emu")
1441     echo "vim-emu running at ${VIMEMU_HOSTNAME} ..."
1442     # print vim-emu connection info
1443     echo -e "\nYou might be interested in adding the following vim-emu env variables to your .bashrc file:"
1444     echo "     export VIMEMU_HOSTNAME=${VIMEMU_HOSTNAME}"
1445     echo -e "To add the emulated VIM to OSM you should do:"
1446     echo "     osm vim-create --name emu-vim1 --user username --password password --auth_url http://${VIMEMU_HOSTNAME}:6001/v2.0 --tenant tenantName --account_type openstack"
1447 }
1448
1449 function install_k8s_monitoring() {
1450     # install OSM monitoring
1451     $WORKDIR_SUDO chmod +x $OSM_DEVOPS/installers/k8s/*.sh
1452     $WORKDIR_SUDO $OSM_DEVOPS/installers/k8s/install_osm_k8s_monitoring.sh
1453 }
1454
1455 function uninstall_k8s_monitoring() {
1456     # uninstall OSM monitoring
1457     $WORKDIR_SUDO $OSM_DEVOPS/installers/k8s/uninstall_osm_k8s_monitoring.sh
1458 }
1459
1460 function dump_vars(){
1461     echo "DEVELOP=$DEVELOP"
1462     echo "INSTALL_FROM_SOURCE=$INSTALL_FROM_SOURCE"
1463     echo "UNINSTALL=$UNINSTALL"
1464     echo "UPDATE=$UPDATE"
1465     echo "RECONFIGURE=$RECONFIGURE"
1466     echo "TEST_INSTALLER=$TEST_INSTALLER"
1467     echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
1468     echo "INSTALL_PLA=$INSTALL_PLA"
1469     echo "INSTALL_LXD=$INSTALL_LXD"
1470     echo "INSTALL_LIGHTWEIGHT=$INSTALL_LIGHTWEIGHT"
1471     echo "INSTALL_ONLY=$INSTALL_ONLY"
1472     echo "INSTALL_ELK=$INSTALL_ELK"
1473     echo "INSTALL_NOCACHELXDIMAGES=$INSTALL_NOCACHELXDIMAGES"
1474     #echo "INSTALL_PERFMON=$INSTALL_PERFMON"
1475     echo "INSTALL_TO_OPENSTACK=$INSTALL_TO_OPENSTACK"
1476     echo "OPENSTACK_PUBLIC_NET_NAME=$OPENSTACK_PUBLIC_NET_NAME"
1477     echo "OPENSTACK_OPENRC_FILE_OR_CLOUD=$OPENSTACK_OPENRC_FILE_OR_CLOUD"
1478     echo "OPENSTACK_ATTACH_VOLUME=$OPENSTACK_ATTACH_VOLUME"
1479     echo "OPENSTACK_SSH_KEY_FILE"="$OPENSTACK_SSH_KEY_FILE"
1480     echo "OPENSTACK_USERDATA_FILE"="$OPENSTACK_USERDATA_FILE"
1481     echo "OPENSTACK_VM_NAME"="$OPENSTACK_VM_NAME"
1482     echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
1483     echo "TO_REBUILD=$TO_REBUILD"
1484     echo "INSTALL_NOLXD=$INSTALL_NOLXD"
1485     echo "INSTALL_NODOCKER=$INSTALL_NODOCKER"
1486     echo "INSTALL_NOJUJU=$INSTALL_NOJUJU"
1487     echo "RELEASE=$RELEASE"
1488     echo "REPOSITORY=$REPOSITORY"
1489     echo "REPOSITORY_BASE=$REPOSITORY_BASE"
1490     echo "REPOSITORY_KEY=$REPOSITORY_KEY"
1491     echo "OSM_DEVOPS=$OSM_DEVOPS"
1492     echo "OSM_VCA_HOST=$OSM_VCA_HOST"
1493     echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
1494     echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
1495     echo "NO_HOST_PORTS=$NO_HOST_PORTS"
1496     echo "DOCKER_NOBUILD=$DOCKER_NOBUILD"
1497     echo "WORKDIR_SUDO=$WORKDIR_SUDO"
1498     echo "OSM_WORK_DIR=$OSM_WORK_DIR"
1499     echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
1500     echo "DOCKER_USER=$DOCKER_USER"
1501     echo "OSM_STACK_NAME=$OSM_STACK_NAME"
1502     echo "PULL_IMAGES=$PULL_IMAGES"
1503     echo "KUBERNETES=$KUBERNETES"
1504     echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL"
1505     echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL"
1506     echo "SHOWOPTS=$SHOWOPTS"
1507     echo "Install from specific refspec (-b): $COMMIT_ID"
1508 }
1509
1510 function track(){
1511     ctime=`date +%s`
1512     duration=$((ctime - SESSION_ID))
1513     url="http://www.woopra.com/track/ce?project=osm.etsi.org&cookie=${SESSION_ID}"
1514     #url="${url}&ce_campaign_name=${CAMPAIGN_NAME}"
1515     event_name="bin"
1516     [ -z "$INSTALL_LIGHTWEIGHT" ] && [ -n "$INSTALL_FROM_SOURCE" ] && event_name="binsrc"
1517     [ -z "$INSTALL_LIGHTWEIGHT" ] && [ -n "$INSTALL_FROM_LXDIMAGES" ] && event_name="lxd"
1518     [ -n "$INSTALL_LIGHTWEIGHT" ] && event_name="lw"
1519     event_name="${event_name}_$1"
1520     url="${url}&event=${event_name}&ce_duration=${duration}"
1521     wget -q -O /dev/null $url
1522 }
1523
1524 function parse_docker_registry_url() {
1525     DOCKER_REGISTRY_USER=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}')
1526     DOCKER_REGISTRY_PASSWORD=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}')
1527     DOCKER_REGISTRY_URL=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); print a[2]}')
1528 }
1529
1530 LXD_VERSION=4.17
1531 JUJU_VERSION=2.8
1532 JUJU_AGENT_VERSION=2.8.6
1533 UNINSTALL=""
1534 DEVELOP=""
1535 UPDATE=""
1536 RECONFIGURE=""
1537 TEST_INSTALLER=""
1538 INSTALL_LXD=""
1539 SHOWOPTS=""
1540 COMMIT_ID=""
1541 ASSUME_YES=""
1542 INSTALL_FROM_SOURCE=""
1543 RELEASE="ReleaseTEN"
1544 REPOSITORY="stable"
1545 INSTALL_VIMEMU=""
1546 INSTALL_PLA=""
1547 LXD_REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/lxd"
1548 LXD_REPOSITORY_PATH=""
1549 INSTALL_LIGHTWEIGHT="y"
1550 INSTALL_TO_OPENSTACK=""
1551 OPENSTACK_OPENRC_FILE_OR_CLOUD=""
1552 OPENSTACK_PUBLIC_NET_NAME=""
1553 OPENSTACK_ATTACH_VOLUME="false"
1554 OPENSTACK_SSH_KEY_FILE=""
1555 OPENSTACK_USERDATA_FILE=""
1556 OPENSTACK_VM_NAME="server-osm"
1557 OPENSTACK_PYTHON_VENV="$HOME/.virtual-envs/osm"
1558 INSTALL_ONLY=""
1559 INSTALL_ELK=""
1560 TO_REBUILD=""
1561 INSTALL_NOLXD=""
1562 INSTALL_NODOCKER=""
1563 INSTALL_NOJUJU=""
1564 KUBERNETES="y"
1565 INSTALL_K8S_MONITOR=""
1566 INSTALL_NOHOSTCLIENT=""
1567 INSTALL_NOCACHELXDIMAGES=""
1568 SESSION_ID=`date +%s`
1569 OSM_DEVOPS=
1570 OSM_VCA_HOST=
1571 OSM_VCA_SECRET=
1572 OSM_VCA_PUBKEY=
1573 OSM_VCA_CLOUDNAME="localhost"
1574 OSM_VCA_K8S_CLOUDNAME="k8scloud"
1575 OSM_STACK_NAME=osm
1576 NO_HOST_PORTS=""
1577 DOCKER_NOBUILD=""
1578 REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
1579 REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian"
1580 WORKDIR_SUDO=sudo
1581 OSM_WORK_DIR="/etc/osm"
1582 OSM_DOCKER_WORK_DIR="/etc/osm/docker"
1583 OSM_K8S_WORK_DIR="${OSM_DOCKER_WORK_DIR}/osm_pods"
1584 OSM_HOST_VOL="/var/lib/osm"
1585 OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1586 OSM_DOCKER_TAG=latest
1587 DOCKER_USER=opensourcemano
1588 PULL_IMAGES="y"
1589 KAFKA_TAG=2.11-1.0.2
1590 PROMETHEUS_TAG=v2.4.3
1591 GRAFANA_TAG=latest
1592 PROMETHEUS_NODE_EXPORTER_TAG=0.18.1
1593 PROMETHEUS_CADVISOR_TAG=latest
1594 KEYSTONEDB_TAG=10
1595 OSM_DATABASE_COMMONKEY=
1596 ELASTIC_VERSION=6.4.2
1597 ELASTIC_CURATOR_VERSION=5.5.4
1598 POD_NETWORK_CIDR=10.244.0.0/16
1599 K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
1600 RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
1601 DOCKER_REGISTRY_URL=
1602 DOCKER_PROXY_URL=
1603 MODULE_DOCKER_TAG=
1604
1605 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
1606     case "${o}" in
1607         b)
1608             COMMIT_ID=${OPTARG}
1609             PULL_IMAGES=""
1610             ;;
1611         r)
1612             REPOSITORY="${OPTARG}"
1613             REPO_ARGS+=(-r "$REPOSITORY")
1614             ;;
1615         c)
1616             [ "${OPTARG}" == "swarm" ] && KUBERNETES="" && REPO_ARGS+=(-c "${OPTARG}") && continue
1617             [ "${OPTARG}" == "k8s" ] && KUBERNETES="y" && continue
1618             echo -e "Invalid argument for -i : ' $OPTARG'\n" >&2
1619             usage && exit 1
1620             ;;
1621         k)
1622             REPOSITORY_KEY="${OPTARG}"
1623             REPO_ARGS+=(-k "$REPOSITORY_KEY")
1624             ;;
1625         u)
1626             REPOSITORY_BASE="${OPTARG}"
1627             REPO_ARGS+=(-u "$REPOSITORY_BASE")
1628             ;;
1629         R)
1630             RELEASE="${OPTARG}"
1631             REPO_ARGS+=(-R "$RELEASE")
1632             ;;
1633         D)
1634             OSM_DEVOPS="${OPTARG}"
1635             ;;
1636         o)
1637             INSTALL_ONLY="y"
1638             [ "${OPTARG}" == "vimemu" ] && INSTALL_VIMEMU="y" && continue
1639             [ "${OPTARG}" == "elk_stack" ] && INSTALL_ELK="y" && continue
1640             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1641             ;;
1642         O)
1643             INSTALL_TO_OPENSTACK="y"
1644             if [ -n "${OPTARG}" ]; then
1645                 OPENSTACK_OPENRC_FILE_OR_CLOUD="${OPTARG}"
1646             else
1647                 echo -e "Invalid argument for -O : ' $OPTARG'\n" >&2
1648                 usage && exit 1
1649             fi
1650             ;;
1651         f)
1652             OPENSTACK_SSH_KEY_FILE="${OPTARG}"
1653             ;;
1654         F)
1655             OPENSTACK_USERDATA_FILE="${OPTARG}"
1656             ;;
1657         N)
1658             OPENSTACK_PUBLIC_NET_NAME="${OPTARG}"
1659             ;;
1660         m)
1661             [ "${OPTARG}" == "NG-UI" ] && TO_REBUILD="$TO_REBUILD NG-UI" && continue
1662             [ "${OPTARG}" == "NBI" ] && TO_REBUILD="$TO_REBUILD NBI" && continue
1663             [ "${OPTARG}" == "LCM" ] && TO_REBUILD="$TO_REBUILD LCM" && continue
1664             [ "${OPTARG}" == "RO" ] && TO_REBUILD="$TO_REBUILD RO" && continue
1665             [ "${OPTARG}" == "MON" ] && TO_REBUILD="$TO_REBUILD MON" && continue
1666             [ "${OPTARG}" == "POL" ] && TO_REBUILD="$TO_REBUILD POL" && continue
1667             [ "${OPTARG}" == "PLA" ] && TO_REBUILD="$TO_REBUILD PLA" && continue
1668             [ "${OPTARG}" == "osmclient" ] && TO_REBUILD="$TO_REBUILD osmclient" && continue
1669             [ "${OPTARG}" == "KAFKA" ] && TO_REBUILD="$TO_REBUILD KAFKA" && continue
1670             [ "${OPTARG}" == "MONGO" ] && TO_REBUILD="$TO_REBUILD MONGO" && continue
1671             [ "${OPTARG}" == "PROMETHEUS" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS" && continue
1672             [ "${OPTARG}" == "PROMETHEUS-CADVISOR" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS-CADVISOR" && continue
1673             [ "${OPTARG}" == "KEYSTONE-DB" ] && TO_REBUILD="$TO_REBUILD KEYSTONE-DB" && continue
1674             [ "${OPTARG}" == "GRAFANA" ] && TO_REBUILD="$TO_REBUILD GRAFANA" && continue
1675             [ "${OPTARG}" == "NONE" ] && TO_REBUILD="$TO_REBUILD NONE" && continue
1676             ;;
1677         H)
1678             OSM_VCA_HOST="${OPTARG}"
1679             ;;
1680         S)
1681             OSM_VCA_SECRET="${OPTARG}"
1682             ;;
1683         s)
1684             OSM_STACK_NAME="${OPTARG}" && [ -n "$KUBERNETES" ] && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
1685             ;;
1686         w)
1687             # when specifying workdir, do not use sudo for access
1688             WORKDIR_SUDO=
1689             OSM_WORK_DIR="${OPTARG}"
1690             ;;
1691         t)
1692             OSM_DOCKER_TAG="${OPTARG}"
1693             REPO_ARGS+=(-t "$OSM_DOCKER_TAG")
1694             ;;
1695         U)
1696             DOCKER_USER="${OPTARG}"
1697             ;;
1698         P)
1699             OSM_VCA_PUBKEY=$(cat ${OPTARG})
1700             ;;
1701         A)
1702             OSM_VCA_APIPROXY="${OPTARG}"
1703             ;;
1704         l)
1705             LXD_CLOUD_FILE="${OPTARG}"
1706             ;;
1707         L)
1708             LXD_CRED_FILE="${OPTARG}"
1709             ;;
1710         K)
1711             CONTROLLER_NAME="${OPTARG}"
1712             ;;
1713         d)
1714             DOCKER_REGISTRY_URL="${OPTARG}"
1715             ;;
1716         p)
1717             DOCKER_PROXY_URL="${OPTARG}"
1718             ;;
1719         T)
1720             MODULE_DOCKER_TAG="${OPTARG}"
1721             ;;
1722         -)
1723             [ "${OPTARG}" == "help" ] && usage && exit 0
1724             [ "${OPTARG}" == "source" ] && INSTALL_FROM_SOURCE="y" && PULL_IMAGES="" && continue
1725             [ "${OPTARG}" == "develop" ] && DEVELOP="y" && continue
1726             [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue
1727             [ "${OPTARG}" == "update" ] && UPDATE="y" && continue
1728             [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE="y" && continue
1729             [ "${OPTARG}" == "test" ] && TEST_INSTALLER="y" && continue
1730             [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD="y" && continue
1731             [ "${OPTARG}" == "nolxd" ] && INSTALL_NOLXD="y" && continue
1732             [ "${OPTARG}" == "nodocker" ] && INSTALL_NODOCKER="y" && continue
1733             [ "${OPTARG}" == "lightweight" ] && INSTALL_LIGHTWEIGHT="y" && continue
1734             [ "${OPTARG}" == "vimemu" ] && INSTALL_VIMEMU="y" && continue
1735             [ "${OPTARG}" == "elk_stack" ] && INSTALL_ELK="y" && continue
1736             [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue
1737             [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS="y" && continue
1738             [ "${OPTARG}" == "nojuju" ] && INSTALL_NOJUJU="y" && continue
1739             [ "${OPTARG}" == "nodockerbuild" ] && DOCKER_NOBUILD="y" && continue
1740             [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue
1741             [ "${OPTARG}" == "pullimages" ] && continue
1742             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1743             [ "${OPTARG}" == "charmed" ] && CHARMED="y" && continue
1744             [ "${OPTARG}" == "bundle" ] && continue
1745             [ "${OPTARG}" == "k8s" ] && continue
1746             [ "${OPTARG}" == "lxd" ] && continue
1747             [ "${OPTARG}" == "lxd-cred" ] && continue
1748             [ "${OPTARG}" == "microstack" ] && continue
1749             [ "${OPTARG}" == "overlay" ] && continue
1750             [ "${OPTARG}" == "only-vca" ] && continue
1751             [ "${OPTARG}" == "vca" ] && continue
1752             [ "${OPTARG}" == "ha" ] && continue
1753             [ "${OPTARG}" == "tag" ] && continue
1754             [ "${OPTARG}" == "registry" ] && continue
1755             [ "${OPTARG}" == "pla" ] && INSTALL_PLA="y" && continue
1756             [ "${OPTARG}" == "volume" ] && OPENSTACK_ATTACH_VOLUME="true" && continue
1757             [ "${OPTARG}" == "nocachelxdimages" ] && INSTALL_NOCACHELXDIMAGES="y" && continue
1758             echo -e "Invalid option: '--$OPTARG'\n" >&2
1759             usage && exit 1
1760             ;;
1761         :)
1762             echo "Option -$OPTARG requires an argument" >&2
1763             usage && exit 1
1764             ;;
1765         \?)
1766             echo -e "Invalid option: '-$OPTARG'\n" >&2
1767             usage && exit 1
1768             ;;
1769         h)
1770             usage && exit 0
1771             ;;
1772         y)
1773             ASSUME_YES="y"
1774             ;;
1775         *)
1776             usage && exit 1
1777             ;;
1778     esac
1779 done
1780
1781 [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url
1782 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" != " NONE" ] && echo $TO_REBUILD | grep -q NONE && FATAL "Incompatible option: -m NONE cannot be used with other -m options"
1783 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" == " PLA" ] && [ -z "$INSTALL_PLA" ] && FATAL "Incompatible option: -m PLA cannot be used without --pla option"
1784
1785 if [ -n "$SHOWOPTS" ]; then
1786     dump_vars
1787     exit 0
1788 fi
1789
1790 if [ -n "$CHARMED" ]; then
1791      if [ -n "$UNINSTALL" ]; then
1792         ${OSM_DEVOPS}/installers/charmed_uninstall.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D /usr/share/osm-devops -t $DOCKER_TAG "$@"
1793      else
1794         ${OSM_DEVOPS}/installers/charmed_install.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D /usr/share/osm-devops -t $DOCKER_TAG "$@"
1795      fi
1796
1797      exit 0
1798 fi
1799
1800 # if develop, we force master
1801 [ -z "$COMMIT_ID" ] && [ -n "$DEVELOP" ] && COMMIT_ID="master"
1802
1803 need_packages="git wget curl tar"
1804
1805 [ -n "$INSTALL_TO_OPENSTACK" ] && install_to_openstack $OPENSTACK_OPENRC_FILE_OR_CLOUD $OPENSTACK_PUBLIC_NET_NAME $OPENSTACK_ATTACH_VOLUME && echo -e "\nDONE" && exit 0
1806
1807 echo -e "Checking required packages: $need_packages"
1808 dpkg -l $need_packages &>/dev/null \
1809   || ! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1810   || sudo apt-get update \
1811   || FATAL "failed to run apt-get update"
1812 dpkg -l $need_packages &>/dev/null \
1813   || ! echo -e "Installing $need_packages requires root privileges." \
1814   || sudo apt-get install -y $need_packages \
1815   || FATAL "failed to install $need_packages"
1816 sudo snap install jq
1817 if [ -z "$OSM_DEVOPS" ]; then
1818     if [ -n "$TEST_INSTALLER" ]; then
1819         echo -e "\nUsing local devops repo for OSM installation"
1820         OSM_DEVOPS="$(dirname $(realpath $(dirname $0)))"
1821     else
1822         echo -e "\nCreating temporary dir for OSM installation"
1823         OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")"
1824         trap 'rm -rf "$OSM_DEVOPS"' EXIT
1825
1826         git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS
1827
1828         if [ -z "$COMMIT_ID" ]; then
1829             echo -e "\nGuessing the current stable release"
1830             LATEST_STABLE_DEVOPS=`git -C $OSM_DEVOPS tag -l v[0-9].* | sort -V | tail -n1`
1831             [ -z "$LATEST_STABLE_DEVOPS" ] && echo "Could not find the current latest stable release" && exit 0
1832
1833             echo "Latest tag in devops repo: $LATEST_STABLE_DEVOPS"
1834             COMMIT_ID="tags/$LATEST_STABLE_DEVOPS"
1835         else
1836             echo -e "\nDEVOPS Using commit $COMMIT_ID"
1837         fi
1838         git -C $OSM_DEVOPS checkout $COMMIT_ID
1839     fi
1840 fi
1841
1842 . $OSM_DEVOPS/common/all_funcs
1843
1844 [ "${OSM_STACK_NAME}" == "osm" ] || OSM_DOCKER_WORK_DIR="$OSM_WORK_DIR/stack/$OSM_STACK_NAME"
1845 [ -n "$KUBERNETES" ] && OSM_K8S_WORK_DIR="$OSM_DOCKER_WORK_DIR/osm_pods" && OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1846 [ -n "$INSTALL_LIGHTWEIGHT" ] && [ -n "$UNINSTALL" ] && uninstall_lightweight && echo -e "\nDONE" && exit 0
1847 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_ELK" ] && deploy_elk
1848 #[ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_PERFMON" ] && deploy_perfmon
1849 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_VIMEMU" ] && install_vimemu
1850 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
1851 [ -n "$INSTALL_ONLY" ] && echo -e "\nDONE" && exit 0
1852
1853 #Installation starts here
1854 wget -q -O- https://osm-download.etsi.org/ftp/osm-10.0-ten/README.txt &> /dev/null
1855 track start
1856
1857 [ -n "$INSTALL_LIGHTWEIGHT" ] && install_lightweight && echo -e "\nDONE" && exit 0
1858 echo -e "\nInstalling OSM from refspec: $COMMIT_ID"
1859 if [ -n "$INSTALL_FROM_SOURCE" ] && [ -z "$ASSUME_YES" ]; then
1860     ! ask_user "The installation will take about 75-90 minutes. Continue (Y/n)? " y && echo "Cancelled!" && exit 1
1861 fi
1862
1863 echo -e "Checking required packages: lxd"
1864 lxd --version &>/dev/null || FATAL "lxd not present, exiting."
1865 [ -n "$INSTALL_LXD" ] && echo -e "\nInstalling and configuring lxd" && install_lxd
1866
1867 # use local devops for containers
1868 export OSM_USE_LOCAL_DEVOPS=true
1869
1870 #Install osmclient
1871
1872 #Install vim-emu (optional)
1873 [ -n "$INSTALL_VIMEMU" ] && install_docker_ce && install_vimemu
1874
1875 wget -q -O- https://osm-download.etsi.org/ftp/osm-10.0-ten/README2.txt &> /dev/null
1876 track end
1877 echo -e "\nDONE"