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     juju deploy ch:mongodb-k8s -m $OSM_STACK_NAME
 905 }
 906
 907 function deploy_osm_pla_service() {
 908     # corresponding to namespace_vol
 909     $WORKDIR_SUDO  sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_DOCKER_WORK_DIR/osm_pla/pla.yaml
 910     # corresponding to deploy_osm_services
 911     kubectl apply -n $OSM_STACK_NAME -f $OSM_DOCKER_WORK_DIR/osm_pla
 912 }
 913
 914 #Install Helm v3
 915 function install_helm() {
 916     helm > /dev/null 2>&1
 917     if [ $? != 0 ] ; then
 918         # Helm is not installed. Install helm
 919         echo "Helm is not installed, installing ..."
 920         curl https://get.helm.sh/helm-v3.6.3-linux-amd64.tar.gz --output helm-v3.6.3.tar.gz
 921         tar -zxvf helm-v3.6.3.tar.gz
 922         sudo mv linux-amd64/helm /usr/local/bin/helm
 923         rm -r linux-amd64
 924         rm helm-v3.6.3.tar.gz
 925         helm repo add stable https://charts.helm.sh/stable
 926         helm repo update
 927     fi
 928 }
 929
 930 function parse_yaml() {
 931     TAG=$1
 932     shift
 933     services=$@
 934     for module in $services; do
 935         if [ "$module" == "pla" ]; then
 936             if [ -n "$INSTALL_PLA" ]; then
 937                 echo "Updating K8s manifest file from opensourcemano\/${module}:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/${module}:${TAG}"
 938                 $WORKDIR_SUDO sed -i "s#opensourcemano/pla:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/pla:${TAG}#g" ${OSM_DOCKER_WORK_DIR}/osm_pla/pla.yaml
 939             fi
 940         else
 941             echo "Updating K8s manifest file from opensourcemano\/${module}:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/${module}:${TAG}"
 942             $WORKDIR_SUDO sed -i "s#opensourcemano/${module}:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module}:${TAG}#g" ${OSM_K8S_WORK_DIR}/${module}.yaml
 943         fi
 944     done
 945 }
 946
 947 function update_manifest_files() {
 948     osm_services="nbi lcm ro pol mon ng-ui keystone pla"
 949     list_of_services=""
 950     for module in $osm_services; do
 951         module_upper="${module^^}"
 952         if ! echo $TO_REBUILD | grep -q $module_upper ; then
 953             list_of_services="$list_of_services $module"
 954         fi
 955     done
 956     if [ ! "$OSM_DOCKER_TAG" == "10" ]; then
 957         parse_yaml $OSM_DOCKER_TAG $list_of_services
 958     fi
 959     if [ -n "$MODULE_DOCKER_TAG" ]; then
 960         parse_yaml $MODULE_DOCKER_TAG $list_of_services_to_rebuild
 961     fi
 962 }
 963
 964 function namespace_vol() {
 965     osm_services="nbi lcm ro pol mon kafka mysql prometheus"
 966     for osm in $osm_services; do
 967         $WORKDIR_SUDO  sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_K8S_WORK_DIR/$osm.yaml
 968     done
 969 }
 970
 971 function init_docker_swarm() {
 972     if [ "${DEFAULT_MTU}" != "1500" ]; then
 973       DOCKER_NETS=`sg docker -c "docker network list" | awk '{print $2}' | egrep -v "^ID$" | paste -d " " -s`
 974       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";}'`
 975       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"
 976     fi
 977     sg docker -c "docker swarm init --advertise-addr ${DEFAULT_IP}"
 978     return 0
 979 }
 980
 981 function create_docker_network() {
 982     echo "creating network"
 983     sg docker -c "docker network create --driver=overlay --attachable --opt com.docker.network.driver.mtu=${DEFAULT_MTU} net${OSM_STACK_NAME}"
 984     echo "creating network DONE"
 985 }
 986
 987 function deploy_lightweight() {
 988
 989     echo "Deploying lightweight build"
 990     OSM_NBI_PORT=9999
 991     OSM_RO_PORT=9090
 992     OSM_KEYSTONE_PORT=5000
 993     OSM_UI_PORT=80
 994     OSM_MON_PORT=8662
 995     OSM_PROM_PORT=9090
 996     OSM_PROM_CADVISOR_PORT=8080
 997     OSM_PROM_HOSTPORT=9091
 998     OSM_GRAFANA_PORT=3000
 999     [ -n "$INSTALL_ELK" ] && OSM_ELK_PORT=5601
1000     #[ -n "$INSTALL_PERFMON" ] && OSM_PM_PORT=3000
1001
1002     if [ -n "$NO_HOST_PORTS" ]; then
1003         OSM_PORTS+=(OSM_NBI_PORTS=$OSM_NBI_PORT)
1004         OSM_PORTS+=(OSM_RO_PORTS=$OSM_RO_PORT)
1005         OSM_PORTS+=(OSM_KEYSTONE_PORTS=$OSM_KEYSTONE_PORT)
1006         OSM_PORTS+=(OSM_UI_PORTS=$OSM_UI_PORT)
1007         OSM_PORTS+=(OSM_MON_PORTS=$OSM_MON_PORT)
1008         OSM_PORTS+=(OSM_PROM_PORTS=$OSM_PROM_PORT)
1009         OSM_PORTS+=(OSM_PROM_CADVISOR_PORTS=$OSM_PROM_CADVISOR_PORT)
1010         OSM_PORTS+=(OSM_GRAFANA_PORTS=$OSM_GRAFANA_PORT)
1011         #[ -n "$INSTALL_PERFMON" ] && OSM_PORTS+=(OSM_PM_PORTS=$OSM_PM_PORT)
1012         [ -n "$INSTALL_ELK" ] && OSM_PORTS+=(OSM_ELK_PORTS=$OSM_ELK_PORT)
1013     else
1014         OSM_PORTS+=(OSM_NBI_PORTS=$OSM_NBI_PORT:$OSM_NBI_PORT)
1015         OSM_PORTS+=(OSM_RO_PORTS=$OSM_RO_PORT:$OSM_RO_PORT)
1016         OSM_PORTS+=(OSM_KEYSTONE_PORTS=$OSM_KEYSTONE_PORT:$OSM_KEYSTONE_PORT)
1017         OSM_PORTS+=(OSM_UI_PORTS=$OSM_UI_PORT:$OSM_UI_PORT)
1018         OSM_PORTS+=(OSM_MON_PORTS=$OSM_MON_PORT:$OSM_MON_PORT)
1019         OSM_PORTS+=(OSM_PROM_PORTS=$OSM_PROM_HOSTPORT:$OSM_PROM_PORT)
1020         OSM_PORTS+=(OSM_PROM_CADVISOR_PORTS=$OSM_PROM_CADVISOR_PORT:$OSM_PROM_CADVISOR_PORT)
1021         OSM_PORTS+=(OSM_GRAFANA_PORTS=$OSM_GRAFANA_PORT:$OSM_GRAFANA_PORT)
1022         #[ -n "$INSTALL_PERFMON" ] && OSM_PORTS+=(OSM_PM_PORTS=$OSM_PM_PORT:$OSM_PM_PORT)
1023         [ -n "$INSTALL_ELK" ] && OSM_PORTS+=(OSM_ELK_PORTS=$OSM_ELK_PORT:$OSM_ELK_PORT)
1024     fi
1025     echo "export ${OSM_PORTS[@]}" | $WORKDIR_SUDO tee $OSM_DOCKER_WORK_DIR/osm_ports.sh
1026     echo "export OSM_NETWORK=net${OSM_STACK_NAME}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1027     echo "export TAG=${OSM_DOCKER_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1028     echo "export DOCKER_USER=${DOCKER_USER}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1029     echo "export KAFKA_TAG=${KAFKA_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1030     echo "export PROMETHEUS_TAG=${PROMETHEUS_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1031     echo "export KEYSTONEDB_TAG=${KEYSTONEDB_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1032     echo "export PROMETHEUS_CADVISOR_TAG=${PROMETHEUS_CADVISOR_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1033     echo "export GRAFANA_TAG=${GRAFANA_TAG}" | $WORKDIR_SUDO tee --append $OSM_DOCKER_WORK_DIR/osm_ports.sh
1034
1035     pushd $OSM_DOCKER_WORK_DIR
1036     if [ -n "$INSTALL_PLA" ]; then
1037         track deploy_osm_pla
1038         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"
1039     else
1040         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"
1041     fi
1042     popd
1043
1044     echo "Finished deployment of lightweight build"
1045 }
1046
1047 function deploy_elk() {
1048     echo "Pulling docker images for ELK"
1049     sg docker -c "docker pull docker.elastic.co/elasticsearch/elasticsearch-oss:${ELASTIC_VERSION}" || FATAL "cannot get elasticsearch docker image"
1050     sg docker -c "docker pull docker.elastic.co/beats/metricbeat:${ELASTIC_VERSION}" || FATAL "cannot get metricbeat docker image"
1051     sg docker -c "docker pull docker.elastic.co/beats/filebeat:${ELASTIC_VERSION}" || FATAL "cannot get filebeat docker image"
1052     sg docker -c "docker pull docker.elastic.co/kibana/kibana-oss:${ELASTIC_VERSION}" || FATAL "cannot get kibana docker image"
1053     sg docker -c "docker pull bobrik/curator:${ELASTIC_CURATOR_VERSION}" || FATAL "cannot get curator docker image"
1054     echo "Finished pulling elk docker images"
1055     $WORKDIR_SUDO mkdir -p "$OSM_DOCKER_WORK_DIR/osm_elk"
1056     $WORKDIR_SUDO cp -b ${OSM_DEVOPS}/installers/docker/osm_elk/* $OSM_DOCKER_WORK_DIR/osm_elk
1057     remove_stack osm_elk
1058     echo "Deploying ELK stack"
1059     sg docker -c "OSM_NETWORK=net${OSM_STACK_NAME} docker stack deploy -c $OSM_DOCKER_WORK_DIR/osm_elk/docker-compose.yml osm_elk"
1060     echo "Waiting for ELK stack to be up and running"
1061     time=0
1062     step=5
1063     timelength=40
1064     elk_is_up=1
1065     while [ $time -le $timelength ]; do
1066         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
1067             elk_is_up=0
1068             break
1069         fi
1070         sleep $step
1071         time=$((time+step))
1072     done
1073     if [ $elk_is_up -eq 0 ]; then
1074         echo "ELK is up and running. Trying to create index pattern..."
1075         #Create index pattern
1076         curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1077           "http://127.0.0.1:5601/api/saved_objects/index-pattern/filebeat-*" \
1078           -d"{\"attributes\":{\"title\":\"filebeat-*\",\"timeFieldName\":\"@timestamp\"}}" 2>/dev/null
1079         #Make it the default index
1080         curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1081           "http://127.0.0.1:5601/api/kibana/settings/defaultIndex" \
1082           -d"{\"value\":\"filebeat-*\"}" 2>/dev/null
1083     else
1084         echo "Cannot connect to Kibana to create index pattern."
1085         echo "Once Kibana is running, you can use the following instructions to create index pattern:"
1086         echo 'curl -f -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1087           "http://127.0.0.1:5601/api/saved_objects/index-pattern/filebeat-*" \
1088           -d"{\"attributes\":{\"title\":\"filebeat-*\",\"timeFieldName\":\"@timestamp\"}}"'
1089         echo 'curl -XPOST -H "Content-Type: application/json" -H "kbn-xsrf: anything" \
1090           "http://127.0.0.1:5601/api/kibana/settings/defaultIndex" \
1091           -d"{\"value\":\"filebeat-*\"}"'
1092     fi
1093     echo "Finished deployment of ELK stack"
1094     return 0
1095 }
1096
1097 function add_local_k8scluster() {
1098     /usr/bin/osm --all-projects vim-create \
1099       --name _system-osm-vim \
1100       --account_type dummy \
1101       --auth_url http://dummy \
1102       --user osm --password osm --tenant osm \
1103       --description "dummy" \
1104       --config '{management_network_name: mgmt}'
1105     /usr/bin/osm --all-projects k8scluster-add \
1106       --creds ${HOME}/.kube/config \
1107       --vim _system-osm-vim \
1108       --k8s-nets '{"net1": null}' \
1109       --version '1.15' \
1110       --description "OSM Internal Cluster" \
1111       _system-osm-k8s
1112 }
1113
1114 function install_lightweight() {
1115     track checkingroot
1116     [ "$USER" == "root" ] && FATAL "You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges."
1117     track noroot
1118
1119     if [ -n "$KUBERNETES" ]; then
1120         [ -z "$ASSUME_YES" ] && ! ask_user "The installation will do the following
1121         1. Install and configure LXD
1122         2. Install juju
1123         3. Install docker CE
1124         4. Disable swap space
1125         5. Install and initialize Kubernetes
1126         as pre-requirements.
1127         Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1
1128
1129     else
1130         [ -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
1131     fi
1132     track proceed
1133
1134     echo "Installing lightweight build of OSM"
1135     LWTEMPDIR="$(mktemp -d -q --tmpdir "installosmlight.XXXXXX")"
1136     trap 'rm -rf "${LWTEMPDIR}"' EXIT
1137     DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}')
1138     [ -z "$DEFAULT_IF" ] && DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
1139     [ -z "$DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0"
1140     DEFAULT_IP=`ip -o -4 a s ${DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]}'`
1141     [ -z "$DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route"
1142     DEFAULT_MTU=$(ip addr show ${DEFAULT_IF} | perl -ne 'if (/mtu\s(\d+)/) {print $1;}')
1143
1144     # if no host is passed in, we need to install lxd/juju, unless explicilty asked not to
1145     if [ -z "$OSM_VCA_HOST" ] && [ -z "$INSTALL_NOLXD" ] && [ -z "$LXD_CLOUD_FILE" ]; then
1146         need_packages_lw="snapd"
1147         echo -e "Checking required packages: $need_packages_lw"
1148         dpkg -l $need_packages_lw &>/dev/null \
1149           || ! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1150           || sudo apt-get update \
1151           || FATAL "failed to run apt-get update"
1152         dpkg -l $need_packages_lw &>/dev/null \
1153           || ! echo -e "Installing $need_packages_lw requires root privileges." \
1154           || sudo apt-get install -y $need_packages_lw \
1155           || FATAL "failed to install $need_packages_lw"
1156         install_lxd
1157     fi
1158
1159     track prereqok
1160
1161     [ -n "$INSTALL_NODOCKER" ] || (install_docker_ce && track docker_ce)
1162
1163     echo "Creating folders for installation"
1164     [ ! -d "$OSM_DOCKER_WORK_DIR" ] && $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR
1165     [ ! -d "$OSM_DOCKER_WORK_DIR/osm_pla" -a -n "$INSTALL_PLA" ] && $WORKDIR_SUDO mkdir -p $OSM_DOCKER_WORK_DIR/osm_pla
1166     [ -n "$KUBERNETES" ] && $WORKDIR_SUDO cp -b $OSM_DEVOPS/installers/docker/cluster-config.yaml $OSM_DOCKER_WORK_DIR/cluster-config.yaml
1167
1168     #Installs Kubernetes
1169     if [ -n "$KUBERNETES" ]; then
1170         install_kube
1171         track install_k8s
1172         init_kubeadm $OSM_DOCKER_WORK_DIR/cluster-config.yaml
1173         kube_config_dir
1174         track init_k8s
1175         if [ -n "$INSTALL_K8S_MONITOR" ]; then
1176             # uninstall OSM MONITORING
1177             uninstall_k8s_monitoring
1178             track uninstall_k8s_monitoring
1179         fi
1180         #remove old namespace
1181         remove_k8s_namespace $OSM_STACK_NAME
1182         deploy_cni_provider
1183         taint_master_node
1184         install_helm
1185         track install_helm
1186         install_k8s_storageclass
1187         track k8s_storageclass
1188         install_k8s_metallb
1189         track k8s_metallb
1190     else
1191         #install_docker_compose
1192         [ -n "$INSTALL_NODOCKER" ] || init_docker_swarm
1193         track docker_swarm
1194     fi
1195
1196     [ -z "$INSTALL_NOJUJU" ] && install_juju
1197     track juju_install
1198
1199     if [ -z "$OSM_VCA_HOST" ]; then
1200         if [ -z "$CONTROLLER_NAME" ]; then
1201
1202             if [ -n "$KUBERNETES" ]; then
1203                 juju_createcontroller_k8s
1204                 juju_addlxd_cloud
1205             else
1206                 if [ -n "$LXD_CLOUD_FILE" ]; then
1207                     [ -z "$LXD_CRED_FILE" ] && FATAL "The installer needs the LXD credential yaml if the LXD is external"
1208                     OSM_VCA_CLOUDNAME="lxd-cloud"
1209                     juju add-cloud $OSM_VCA_CLOUDNAME $LXD_CLOUD_FILE --force || juju update-cloud $OSM_VCA_CLOUDNAME --client -f $LXD_CLOUD_FILE
1210                     juju add-credential $OSM_VCA_CLOUDNAME -f $LXD_CRED_FILE || juju update-credential $OSM_VCA_CLOUDNAME lxd-cloud-creds -f $LXD_CRED_FILE
1211                 fi
1212                 juju_createcontroller
1213                 juju_createproxy
1214             fi
1215         else
1216             OSM_VCA_CLOUDNAME="lxd-cloud"
1217             if [ -n "$LXD_CLOUD_FILE" ]; then
1218                 [ -z "$LXD_CRED_FILE" ] && FATAL "The installer needs the LXD credential yaml if the LXD is external"
1219                 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
1220                 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
1221             else
1222                 mkdir -p ~/.osm
1223                 cat << EOF > ~/.osm/lxd-cloud.yaml
1224 clouds:
1225   lxd-cloud:
1226     type: lxd
1227     auth-types: [certificate]
1228     endpoint: "https://$DEFAULT_IP:8443"
1229     config:
1230       ssl-hostname-verification: false
1231 EOF
1232                 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"
1233                 local server_cert=`cat /var/snap/lxd/common/lxd/server.crt | sed 's/^/        /'`
1234                 local client_cert=`cat ~/.osm/client.crt | sed 's/^/        /'`
1235                 local client_key=`cat ~/.osm/client.key | sed 's/^/        /'`
1236                 cat << EOF > ~/.osm/lxd-credentials.yaml
1237 credentials:
1238   lxd-cloud:
1239     lxd-cloud:
1240       auth-type: certificate
1241       server-cert: |
1242 $server_cert
1243       client-cert: |
1244 $client_cert
1245       client-key: |
1246 $client_key
1247 EOF
1248                 lxc config trust add local: ~/.osm/client.crt
1249                 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
1250                 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
1251             fi
1252         fi
1253         [ -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}'`
1254         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`juju show-controller $CONTROLLER_NAME |grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
1255         [ -z "$OSM_VCA_HOST" ] && FATAL "Cannot obtain juju controller IP address"
1256     fi
1257     track juju_controller
1258
1259     if [ -z "$OSM_VCA_SECRET" ]; then
1260         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $OSM_STACK_NAME)
1261         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $CONTROLLER_NAME)
1262         [ -z "$OSM_VCA_SECRET" ] && FATAL "Cannot obtain juju secret"
1263     fi
1264     if [ -z "$OSM_VCA_PUBKEY" ]; then
1265         OSM_VCA_PUBKEY=$(cat $HOME/.local/share/juju/ssh/juju_id_rsa.pub)
1266         [ -z "$OSM_VCA_PUBKEY" ] && FATAL "Cannot obtain juju public key"
1267     fi
1268     if [ -z "$OSM_VCA_CACERT" ]; then
1269         [ -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)
1270         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $CONTROLLER_NAME '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
1271        [ -z "$OSM_VCA_CACERT" ] && FATAL "Cannot obtain juju CA certificate"
1272     fi
1273
1274     # Set OSM_VCA_APIPROXY only when it is not a k8s installation
1275     if [ -z "$KUBERNETES" ]; then
1276         if [ -z "$OSM_VCA_APIPROXY" ]; then
1277             OSM_VCA_APIPROXY=$DEFAULT_IP
1278             [ -z "$OSM_VCA_APIPROXY" ] && FATAL "Cannot obtain juju api proxy"
1279         fi
1280         juju_createproxy
1281     fi
1282     track juju
1283
1284     if [ -z "$OSM_DATABASE_COMMONKEY" ]; then
1285         OSM_DATABASE_COMMONKEY=$(generate_secret)
1286         [ -z "OSM_DATABASE_COMMONKEY" ] && FATAL "Cannot generate common db secret"
1287     fi
1288
1289     # Deploy OSM services
1290     [ -z "$DOCKER_NOBUILD" ] && generate_docker_images
1291     track docker_build
1292
1293     if [ -n "$KUBERNETES" ]; then
1294         generate_k8s_manifest_files
1295     else
1296         generate_docker_compose_files
1297     fi
1298     track manifest_files
1299     generate_prometheus_grafana_files
1300     generate_docker_env_files
1301     track env_files
1302
1303     if [ -n "$KUBERNETES" ]; then
1304         deploy_charmed_services
1305         kube_secrets
1306         update_manifest_files
1307         namespace_vol
1308         deploy_osm_services
1309         if [ -n "$INSTALL_PLA"]; then
1310             # optional PLA install
1311             deploy_osm_pla_service
1312             track deploy_osm_pla
1313         fi
1314         track deploy_osm_services_k8s
1315         if [ -n "$INSTALL_K8S_MONITOR" ]; then
1316             # install OSM MONITORING
1317             install_k8s_monitoring
1318             track install_k8s_monitoring
1319         fi
1320     else
1321         # remove old stack
1322         remove_stack $OSM_STACK_NAME
1323         create_docker_network
1324         deploy_lightweight
1325         generate_osmclient_script
1326         track docker_deploy
1327         install_prometheus_nodeexporter
1328         track nodeexporter
1329         [ -n "$INSTALL_VIMEMU" ] && install_vimemu && track vimemu
1330         [ -n "$INSTALL_ELK" ] && deploy_elk && track elk
1331     fi
1332
1333     [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
1334     track osmclient
1335
1336     echo -e "Checking OSM health state..."
1337     if [ -n "$KUBERNETES" ]; then
1338         $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_STACK_NAME} -k || \
1339         echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
1340         echo -e "Check OSM status with: kubectl -n ${OSM_STACK_NAME} get all" && \
1341         track osm_unhealthy
1342     else
1343         $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_STACK_NAME} || \
1344         echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
1345         echo -e "Check OSM status with: docker service ls; docker stack ps ${OSM_STACK_NAME}" && \
1346         track osm_unhealthy
1347     fi
1348     track after_healthcheck
1349
1350     [ -n "$KUBERNETES" ] && add_local_k8scluster
1351     track add_local_k8scluster
1352
1353     wget -q -O- https://osm-download.etsi.org/ftp/osm-10.0-ten/README2.txt &> /dev/null
1354     track end
1355     return 0
1356 }
1357
1358 function install_to_openstack() {
1359
1360     if [ -z "$2" ]; then
1361         FATAL "OpenStack installer requires a valid external network name"
1362     fi
1363
1364     # Install Pip for Python3
1365     $WORKDIR_SUDO apt install -y python3-pip python3-venv
1366     $WORKDIR_SUDO -H LC_ALL=C python3 -m pip install -U pip
1367
1368     # Create a venv to avoid conflicts with the host installation
1369     python3 -m venv $OPENSTACK_PYTHON_VENV
1370
1371     source $OPENSTACK_PYTHON_VENV/bin/activate
1372
1373     # Install Ansible, OpenStack client and SDK, latest openstack version supported is Train
1374     python -m pip install -U wheel
1375     python -m pip install -U "python-openstackclient<=4.0.2" "openstacksdk>=0.12.0,<=0.36.2" "ansible>=2.10,<2.11"
1376
1377     # Install the Openstack cloud module (ansible>=2.10)
1378     ansible-galaxy collection install openstack.cloud
1379
1380     export ANSIBLE_CONFIG="$OSM_DEVOPS/installers/openstack/ansible.cfg"
1381
1382     OSM_INSTALLER_ARGS="${REPO_ARGS[@]}"
1383
1384     ANSIBLE_VARS="external_network_name=$2 setup_volume=$3 server_name=$OPENSTACK_VM_NAME"
1385
1386     if [ -n "$OPENSTACK_SSH_KEY_FILE" ]; then
1387         ANSIBLE_VARS+=" key_file=$OPENSTACK_SSH_KEY_FILE"
1388     fi
1389
1390     if [ -n "$OPENSTACK_USERDATA_FILE" ]; then
1391         ANSIBLE_VARS+=" userdata_file=$OPENSTACK_USERDATA_FILE"
1392     fi
1393
1394     # Execute the Ansible playbook based on openrc or clouds.yaml
1395     if [ -e "$1" ]; then
1396         . $1
1397         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
1398         $OSM_DEVOPS/installers/openstack/site.yml
1399     else
1400         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
1401         -e cloud_name=$1 $OSM_DEVOPS/installers/openstack/site.yml
1402     fi
1403
1404     # Exit from venv
1405     deactivate
1406
1407     return 0
1408 }
1409
1410 function install_vimemu() {
1411     echo "\nInstalling vim-emu"
1412     EMUTEMPDIR="$(mktemp -d -q --tmpdir "installosmvimemu.XXXXXX")"
1413     trap 'rm -rf "${EMUTEMPDIR}"' EXIT
1414     # install prerequisites (OVS is a must for the emulator to work)
1415     sudo apt-get install openvswitch-switch
1416     # clone vim-emu repository (attention: branch is currently master only)
1417     echo "Cloning vim-emu repository ..."
1418     git clone https://osm.etsi.org/gerrit/osm/vim-emu.git $EMUTEMPDIR
1419     # build vim-emu docker
1420     echo "Building vim-emu Docker container..."
1421
1422     sg docker -c "docker build -t vim-emu-img -f $EMUTEMPDIR/Dockerfile --no-cache $EMUTEMPDIR/" || FATAL "cannot build vim-emu-img docker image"
1423     # start vim-emu container as daemon
1424     echo "Starting vim-emu Docker container 'vim-emu' ..."
1425     if [ -n "$INSTALL_LIGHTWEIGHT" ]; then
1426         # in lightweight mode, the emulator needs to be attached to netOSM
1427         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"
1428     else
1429         # classic build mode
1430         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"
1431     fi
1432     echo "Waiting for 'vim-emu' container to start ..."
1433     sleep 5
1434     export VIMEMU_HOSTNAME=$(sg docker -c "docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' vim-emu")
1435     echo "vim-emu running at ${VIMEMU_HOSTNAME} ..."
1436     # print vim-emu connection info
1437     echo -e "\nYou might be interested in adding the following vim-emu env variables to your .bashrc file:"
1438     echo "     export VIMEMU_HOSTNAME=${VIMEMU_HOSTNAME}"
1439     echo -e "To add the emulated VIM to OSM you should do:"
1440     echo "     osm vim-create --name emu-vim1 --user username --password password --auth_url http://${VIMEMU_HOSTNAME}:6001/v2.0 --tenant tenantName --account_type openstack"
1441 }
1442
1443 function install_k8s_monitoring() {
1444     # install OSM monitoring
1445     $WORKDIR_SUDO chmod +x $OSM_DEVOPS/installers/k8s/*.sh
1446     $WORKDIR_SUDO $OSM_DEVOPS/installers/k8s/install_osm_k8s_monitoring.sh
1447 }
1448
1449 function uninstall_k8s_monitoring() {
1450     # uninstall OSM monitoring
1451     $WORKDIR_SUDO $OSM_DEVOPS/installers/k8s/uninstall_osm_k8s_monitoring.sh
1452 }
1453
1454 function dump_vars(){
1455     echo "DEVELOP=$DEVELOP"
1456     echo "INSTALL_FROM_SOURCE=$INSTALL_FROM_SOURCE"
1457     echo "UNINSTALL=$UNINSTALL"
1458     echo "UPDATE=$UPDATE"
1459     echo "RECONFIGURE=$RECONFIGURE"
1460     echo "TEST_INSTALLER=$TEST_INSTALLER"
1461     echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
1462     echo "INSTALL_PLA=$INSTALL_PLA"
1463     echo "INSTALL_LXD=$INSTALL_LXD"
1464     echo "INSTALL_LIGHTWEIGHT=$INSTALL_LIGHTWEIGHT"
1465     echo "INSTALL_ONLY=$INSTALL_ONLY"
1466     echo "INSTALL_ELK=$INSTALL_ELK"
1467     echo "INSTALL_NOCACHELXDIMAGES=$INSTALL_NOCACHELXDIMAGES"
1468     #echo "INSTALL_PERFMON=$INSTALL_PERFMON"
1469     echo "INSTALL_TO_OPENSTACK=$INSTALL_TO_OPENSTACK"
1470     echo "OPENSTACK_PUBLIC_NET_NAME=$OPENSTACK_PUBLIC_NET_NAME"
1471     echo "OPENSTACK_OPENRC_FILE_OR_CLOUD=$OPENSTACK_OPENRC_FILE_OR_CLOUD"
1472     echo "OPENSTACK_ATTACH_VOLUME=$OPENSTACK_ATTACH_VOLUME"
1473     echo "OPENSTACK_SSH_KEY_FILE"="$OPENSTACK_SSH_KEY_FILE"
1474     echo "OPENSTACK_USERDATA_FILE"="$OPENSTACK_USERDATA_FILE"
1475     echo "OPENSTACK_VM_NAME"="$OPENSTACK_VM_NAME"
1476     echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
1477     echo "TO_REBUILD=$TO_REBUILD"
1478     echo "INSTALL_NOLXD=$INSTALL_NOLXD"
1479     echo "INSTALL_NODOCKER=$INSTALL_NODOCKER"
1480     echo "INSTALL_NOJUJU=$INSTALL_NOJUJU"
1481     echo "RELEASE=$RELEASE"
1482     echo "REPOSITORY=$REPOSITORY"
1483     echo "REPOSITORY_BASE=$REPOSITORY_BASE"
1484     echo "REPOSITORY_KEY=$REPOSITORY_KEY"
1485     echo "OSM_DEVOPS=$OSM_DEVOPS"
1486     echo "OSM_VCA_HOST=$OSM_VCA_HOST"
1487     echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
1488     echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
1489     echo "NO_HOST_PORTS=$NO_HOST_PORTS"
1490     echo "DOCKER_NOBUILD=$DOCKER_NOBUILD"
1491     echo "WORKDIR_SUDO=$WORKDIR_SUDO"
1492     echo "OSM_WORK_DIR=$OSM_WORK_DIR"
1493     echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
1494     echo "DOCKER_USER=$DOCKER_USER"
1495     echo "OSM_STACK_NAME=$OSM_STACK_NAME"
1496     echo "PULL_IMAGES=$PULL_IMAGES"
1497     echo "KUBERNETES=$KUBERNETES"
1498     echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL"
1499     echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL"
1500     echo "SHOWOPTS=$SHOWOPTS"
1501     echo "Install from specific refspec (-b): $COMMIT_ID"
1502 }
1503
1504 function track(){
1505     ctime=`date +%s`
1506     duration=$((ctime - SESSION_ID))
1507     url="http://www.woopra.com/track/ce?project=osm.etsi.org&cookie=${SESSION_ID}"
1508     #url="${url}&ce_campaign_name=${CAMPAIGN_NAME}"
1509     event_name="bin"
1510     [ -z "$INSTALL_LIGHTWEIGHT" ] && [ -n "$INSTALL_FROM_SOURCE" ] && event_name="binsrc"
1511     [ -z "$INSTALL_LIGHTWEIGHT" ] && [ -n "$INSTALL_FROM_LXDIMAGES" ] && event_name="lxd"
1512     [ -n "$INSTALL_LIGHTWEIGHT" ] && event_name="lw"
1513     event_name="${event_name}_$1"
1514     url="${url}&event=${event_name}&ce_duration=${duration}"
1515     wget -q -O /dev/null $url
1516 }
1517
1518 function parse_docker_registry_url() {
1519     DOCKER_REGISTRY_USER=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}')
1520     DOCKER_REGISTRY_PASSWORD=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}')
1521     DOCKER_REGISTRY_URL=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); print a[2]}')
1522 }
1523
1524 LXD_VERSION=4.17
1525 JUJU_VERSION=2.9
1526 JUJU_AGENT_VERSION=2.9.12
1527 UNINSTALL=""
1528 DEVELOP=""
1529 UPDATE=""
1530 RECONFIGURE=""
1531 TEST_INSTALLER=""
1532 INSTALL_LXD=""
1533 SHOWOPTS=""
1534 COMMIT_ID=""
1535 ASSUME_YES=""
1536 INSTALL_FROM_SOURCE=""
1537 RELEASE="ReleaseTEN"
1538 REPOSITORY="stable"
1539 INSTALL_VIMEMU=""
1540 INSTALL_PLA=""
1541 LXD_REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/lxd"
1542 LXD_REPOSITORY_PATH=""
1543 INSTALL_LIGHTWEIGHT="y"
1544 INSTALL_TO_OPENSTACK=""
1545 OPENSTACK_OPENRC_FILE_OR_CLOUD=""
1546 OPENSTACK_PUBLIC_NET_NAME=""
1547 OPENSTACK_ATTACH_VOLUME="false"
1548 OPENSTACK_SSH_KEY_FILE=""
1549 OPENSTACK_USERDATA_FILE=""
1550 OPENSTACK_VM_NAME="server-osm"
1551 OPENSTACK_PYTHON_VENV="$HOME/.virtual-envs/osm"
1552 INSTALL_ONLY=""
1553 INSTALL_ELK=""
1554 TO_REBUILD=""
1555 INSTALL_NOLXD=""
1556 INSTALL_NODOCKER=""
1557 INSTALL_NOJUJU=""
1558 KUBERNETES="y"
1559 INSTALL_K8S_MONITOR=""
1560 INSTALL_NOHOSTCLIENT=""
1561 INSTALL_NOCACHELXDIMAGES=""
1562 SESSION_ID=`date +%s`
1563 OSM_DEVOPS=
1564 OSM_VCA_HOST=
1565 OSM_VCA_SECRET=
1566 OSM_VCA_PUBKEY=
1567 OSM_VCA_CLOUDNAME="localhost"
1568 OSM_VCA_K8S_CLOUDNAME="k8scloud"
1569 OSM_STACK_NAME=osm
1570 NO_HOST_PORTS=""
1571 DOCKER_NOBUILD=""
1572 REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
1573 REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian"
1574 WORKDIR_SUDO=sudo
1575 OSM_WORK_DIR="/etc/osm"
1576 OSM_DOCKER_WORK_DIR="/etc/osm/docker"
1577 OSM_K8S_WORK_DIR="${OSM_DOCKER_WORK_DIR}/osm_pods"
1578 OSM_HOST_VOL="/var/lib/osm"
1579 OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1580 OSM_DOCKER_TAG=latest
1581 DOCKER_USER=opensourcemano
1582 PULL_IMAGES="y"
1583 KAFKA_TAG=2.11-1.0.2
1584 PROMETHEUS_TAG=v2.4.3
1585 GRAFANA_TAG=latest
1586 PROMETHEUS_NODE_EXPORTER_TAG=0.18.1
1587 PROMETHEUS_CADVISOR_TAG=latest
1588 KEYSTONEDB_TAG=10
1589 OSM_DATABASE_COMMONKEY=
1590 ELASTIC_VERSION=6.4.2
1591 ELASTIC_CURATOR_VERSION=5.5.4
1592 POD_NETWORK_CIDR=10.244.0.0/16
1593 K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
1594 RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
1595 DOCKER_REGISTRY_URL=
1596 DOCKER_PROXY_URL=
1597 MODULE_DOCKER_TAG=
1598
1599 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
1600     case "${o}" in
1601         b)
1602             COMMIT_ID=${OPTARG}
1603             PULL_IMAGES=""
1604             ;;
1605         r)
1606             REPOSITORY="${OPTARG}"
1607             REPO_ARGS+=(-r "$REPOSITORY")
1608             ;;
1609         c)
1610             [ "${OPTARG}" == "swarm" ] && KUBERNETES="" && REPO_ARGS+=(-c "${OPTARG}") && continue
1611             [ "${OPTARG}" == "k8s" ] && KUBERNETES="y" && continue
1612             echo -e "Invalid argument for -i : ' $OPTARG'\n" >&2
1613             usage && exit 1
1614             ;;
1615         k)
1616             REPOSITORY_KEY="${OPTARG}"
1617             REPO_ARGS+=(-k "$REPOSITORY_KEY")
1618             ;;
1619         u)
1620             REPOSITORY_BASE="${OPTARG}"
1621             REPO_ARGS+=(-u "$REPOSITORY_BASE")
1622             ;;
1623         R)
1624             RELEASE="${OPTARG}"
1625             REPO_ARGS+=(-R "$RELEASE")
1626             ;;
1627         D)
1628             OSM_DEVOPS="${OPTARG}"
1629             ;;
1630         o)
1631             INSTALL_ONLY="y"
1632             [ "${OPTARG}" == "vimemu" ] && INSTALL_VIMEMU="y" && continue
1633             [ "${OPTARG}" == "elk_stack" ] && INSTALL_ELK="y" && continue
1634             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1635             ;;
1636         O)
1637             INSTALL_TO_OPENSTACK="y"
1638             if [ -n "${OPTARG}" ]; then
1639                 OPENSTACK_OPENRC_FILE_OR_CLOUD="${OPTARG}"
1640             else
1641                 echo -e "Invalid argument for -O : ' $OPTARG'\n" >&2
1642                 usage && exit 1
1643             fi
1644             ;;
1645         f)
1646             OPENSTACK_SSH_KEY_FILE="${OPTARG}"
1647             ;;
1648         F)
1649             OPENSTACK_USERDATA_FILE="${OPTARG}"
1650             ;;
1651         N)
1652             OPENSTACK_PUBLIC_NET_NAME="${OPTARG}"
1653             ;;
1654         m)
1655             [ "${OPTARG}" == "NG-UI" ] && TO_REBUILD="$TO_REBUILD NG-UI" && continue
1656             [ "${OPTARG}" == "NBI" ] && TO_REBUILD="$TO_REBUILD NBI" && continue
1657             [ "${OPTARG}" == "LCM" ] && TO_REBUILD="$TO_REBUILD LCM" && continue
1658             [ "${OPTARG}" == "RO" ] && TO_REBUILD="$TO_REBUILD RO" && continue
1659             [ "${OPTARG}" == "MON" ] && TO_REBUILD="$TO_REBUILD MON" && continue
1660             [ "${OPTARG}" == "POL" ] && TO_REBUILD="$TO_REBUILD POL" && continue
1661             [ "${OPTARG}" == "PLA" ] && TO_REBUILD="$TO_REBUILD PLA" && continue
1662             [ "${OPTARG}" == "osmclient" ] && TO_REBUILD="$TO_REBUILD osmclient" && continue
1663             [ "${OPTARG}" == "KAFKA" ] && TO_REBUILD="$TO_REBUILD KAFKA" && continue
1664             [ "${OPTARG}" == "MONGO" ] && TO_REBUILD="$TO_REBUILD MONGO" && continue
1665             [ "${OPTARG}" == "PROMETHEUS" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS" && continue
1666             [ "${OPTARG}" == "PROMETHEUS-CADVISOR" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS-CADVISOR" && continue
1667             [ "${OPTARG}" == "KEYSTONE-DB" ] && TO_REBUILD="$TO_REBUILD KEYSTONE-DB" && continue
1668             [ "${OPTARG}" == "GRAFANA" ] && TO_REBUILD="$TO_REBUILD GRAFANA" && continue
1669             [ "${OPTARG}" == "NONE" ] && TO_REBUILD="$TO_REBUILD NONE" && continue
1670             ;;
1671         H)
1672             OSM_VCA_HOST="${OPTARG}"
1673             ;;
1674         S)
1675             OSM_VCA_SECRET="${OPTARG}"
1676             ;;
1677         s)
1678             OSM_STACK_NAME="${OPTARG}" && [ -n "$KUBERNETES" ] && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
1679             ;;
1680         w)
1681             # when specifying workdir, do not use sudo for access
1682             WORKDIR_SUDO=
1683             OSM_WORK_DIR="${OPTARG}"
1684             ;;
1685         t)
1686             OSM_DOCKER_TAG="${OPTARG}"
1687             REPO_ARGS+=(-t "$OSM_DOCKER_TAG")
1688             ;;
1689         U)
1690             DOCKER_USER="${OPTARG}"
1691             ;;
1692         P)
1693             OSM_VCA_PUBKEY=$(cat ${OPTARG})
1694             ;;
1695         A)
1696             OSM_VCA_APIPROXY="${OPTARG}"
1697             ;;
1698         l)
1699             LXD_CLOUD_FILE="${OPTARG}"
1700             ;;
1701         L)
1702             LXD_CRED_FILE="${OPTARG}"
1703             ;;
1704         K)
1705             CONTROLLER_NAME="${OPTARG}"
1706             ;;
1707         d)
1708             DOCKER_REGISTRY_URL="${OPTARG}"
1709             ;;
1710         p)
1711             DOCKER_PROXY_URL="${OPTARG}"
1712             ;;
1713         T)
1714             MODULE_DOCKER_TAG="${OPTARG}"
1715             ;;
1716         -)
1717             [ "${OPTARG}" == "help" ] && usage && exit 0
1718             [ "${OPTARG}" == "source" ] && INSTALL_FROM_SOURCE="y" && PULL_IMAGES="" && continue
1719             [ "${OPTARG}" == "develop" ] && DEVELOP="y" && continue
1720             [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue
1721             [ "${OPTARG}" == "update" ] && UPDATE="y" && continue
1722             [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE="y" && continue
1723             [ "${OPTARG}" == "test" ] && TEST_INSTALLER="y" && continue
1724             [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD="y" && continue
1725             [ "${OPTARG}" == "nolxd" ] && INSTALL_NOLXD="y" && continue
1726             [ "${OPTARG}" == "nodocker" ] && INSTALL_NODOCKER="y" && continue
1727             [ "${OPTARG}" == "lightweight" ] && INSTALL_LIGHTWEIGHT="y" && continue
1728             [ "${OPTARG}" == "vimemu" ] && INSTALL_VIMEMU="y" && continue
1729             [ "${OPTARG}" == "elk_stack" ] && INSTALL_ELK="y" && continue
1730             [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue
1731             [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS="y" && continue
1732             [ "${OPTARG}" == "nojuju" ] && INSTALL_NOJUJU="y" && continue
1733             [ "${OPTARG}" == "nodockerbuild" ] && DOCKER_NOBUILD="y" && continue
1734             [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue
1735             [ "${OPTARG}" == "pullimages" ] && continue
1736             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1737             [ "${OPTARG}" == "charmed" ] && CHARMED="y" && continue
1738             [ "${OPTARG}" == "bundle" ] && continue
1739             [ "${OPTARG}" == "k8s" ] && continue
1740             [ "${OPTARG}" == "lxd" ] && continue
1741             [ "${OPTARG}" == "lxd-cred" ] && continue
1742             [ "${OPTARG}" == "microstack" ] && continue
1743             [ "${OPTARG}" == "overlay" ] && continue
1744             [ "${OPTARG}" == "only-vca" ] && continue
1745             [ "${OPTARG}" == "vca" ] && continue
1746             [ "${OPTARG}" == "ha" ] && continue
1747             [ "${OPTARG}" == "tag" ] && continue
1748             [ "${OPTARG}" == "registry" ] && continue
1749             [ "${OPTARG}" == "pla" ] && INSTALL_PLA="y" && continue
1750             [ "${OPTARG}" == "volume" ] && OPENSTACK_ATTACH_VOLUME="true" && continue
1751             [ "${OPTARG}" == "nocachelxdimages" ] && INSTALL_NOCACHELXDIMAGES="y" && continue
1752             echo -e "Invalid option: '--$OPTARG'\n" >&2
1753             usage && exit 1
1754             ;;
1755         :)
1756             echo "Option -$OPTARG requires an argument" >&2
1757             usage && exit 1
1758             ;;
1759         \?)
1760             echo -e "Invalid option: '-$OPTARG'\n" >&2
1761             usage && exit 1
1762             ;;
1763         h)
1764             usage && exit 0
1765             ;;
1766         y)
1767             ASSUME_YES="y"
1768             ;;
1769         *)
1770             usage && exit 1
1771             ;;
1772     esac
1773 done
1774
1775 [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url
1776 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" != " NONE" ] && echo $TO_REBUILD | grep -q NONE && FATAL "Incompatible option: -m NONE cannot be used with other -m options"
1777 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" == " PLA" ] && [ -z "$INSTALL_PLA" ] && FATAL "Incompatible option: -m PLA cannot be used without --pla option"
1778
1779 if [ -n "$SHOWOPTS" ]; then
1780     dump_vars
1781     exit 0
1782 fi
1783
1784 if [ -n "$CHARMED" ]; then
1785      if [ -n "$UNINSTALL" ]; then
1786         ${OSM_DEVOPS}/installers/charmed_uninstall.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D /usr/share/osm-devops -t $DOCKER_TAG "$@"
1787      else
1788         ${OSM_DEVOPS}/installers/charmed_install.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D /usr/share/osm-devops -t $DOCKER_TAG "$@"
1789      fi
1790
1791      exit 0
1792 fi
1793
1794 # if develop, we force master
1795 [ -z "$COMMIT_ID" ] && [ -n "$DEVELOP" ] && COMMIT_ID="master"
1796
1797 need_packages="git wget curl tar"
1798
1799 [ -n "$INSTALL_TO_OPENSTACK" ] && install_to_openstack $OPENSTACK_OPENRC_FILE_OR_CLOUD $OPENSTACK_PUBLIC_NET_NAME $OPENSTACK_ATTACH_VOLUME && echo -e "\nDONE" && exit 0
1800
1801 echo -e "Checking required packages: $need_packages"
1802 dpkg -l $need_packages &>/dev/null \
1803   || ! echo -e "One or several required packages are not installed. Updating apt cache requires root privileges." \
1804   || sudo apt-get update \
1805   || FATAL "failed to run apt-get update"
1806 dpkg -l $need_packages &>/dev/null \
1807   || ! echo -e "Installing $need_packages requires root privileges." \
1808   || sudo apt-get install -y $need_packages \
1809   || FATAL "failed to install $need_packages"
1810 sudo snap install jq
1811 if [ -z "$OSM_DEVOPS" ]; then
1812     if [ -n "$TEST_INSTALLER" ]; then
1813         echo -e "\nUsing local devops repo for OSM installation"
1814         OSM_DEVOPS="$(dirname $(realpath $(dirname $0)))"
1815     else
1816         echo -e "\nCreating temporary dir for OSM installation"
1817         OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")"
1818         trap 'rm -rf "$OSM_DEVOPS"' EXIT
1819
1820         git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS
1821
1822         if [ -z "$COMMIT_ID" ]; then
1823             echo -e "\nGuessing the current stable release"
1824             LATEST_STABLE_DEVOPS=`git -C $OSM_DEVOPS tag -l v[0-9].* | sort -V | tail -n1`
1825             [ -z "$LATEST_STABLE_DEVOPS" ] && echo "Could not find the current latest stable release" && exit 0
1826
1827             echo "Latest tag in devops repo: $LATEST_STABLE_DEVOPS"
1828             COMMIT_ID="tags/$LATEST_STABLE_DEVOPS"
1829         else
1830             echo -e "\nDEVOPS Using commit $COMMIT_ID"
1831         fi
1832         git -C $OSM_DEVOPS checkout $COMMIT_ID
1833     fi
1834 fi
1835
1836 . $OSM_DEVOPS/common/all_funcs
1837
1838 [ "${OSM_STACK_NAME}" == "osm" ] || OSM_DOCKER_WORK_DIR="$OSM_WORK_DIR/stack/$OSM_STACK_NAME"
1839 [ -n "$KUBERNETES" ] && OSM_K8S_WORK_DIR="$OSM_DOCKER_WORK_DIR/osm_pods" && OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_STACK_NAME}"
1840 [ -n "$INSTALL_LIGHTWEIGHT" ] && [ -n "$UNINSTALL" ] && uninstall_lightweight && echo -e "\nDONE" && exit 0
1841 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_ELK" ] && deploy_elk
1842 #[ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_PERFMON" ] && deploy_perfmon
1843 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_VIMEMU" ] && install_vimemu
1844 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
1845 [ -n "$INSTALL_ONLY" ] && echo -e "\nDONE" && exit 0
1846
1847 #Installation starts here
1848 wget -q -O- https://osm-download.etsi.org/ftp/osm-10.0-ten/README.txt &> /dev/null
1849 track start
1850
1851 [ -n "$INSTALL_LIGHTWEIGHT" ] && install_lightweight && echo -e "\nDONE" && exit 0
1852 echo -e "\nInstalling OSM from refspec: $COMMIT_ID"
1853 if [ -n "$INSTALL_FROM_SOURCE" ] && [ -z "$ASSUME_YES" ]; then
1854     ! ask_user "The installation will take about 75-90 minutes. Continue (Y/n)? " y && echo "Cancelled!" && exit 1
1855 fi
1856
1857 echo -e "Checking required packages: lxd"
1858 lxd --version &>/dev/null || FATAL "lxd not present, exiting."
1859 [ -n "$INSTALL_LXD" ] && echo -e "\nInstalling and configuring lxd" && install_lxd
1860
1861 # use local devops for containers
1862 export OSM_USE_LOCAL_DEVOPS=true
1863
1864 #Install osmclient
1865
1866 #Install vim-emu (optional)
1867 [ -n "$INSTALL_VIMEMU" ] && install_docker_ce && install_vimemu
1868
1869 wget -q -O- https://osm-download.etsi.org/ftp/osm-10.0-ten/README2.txt &> /dev/null
1870 track end
1871 echo -e "\nDONE"