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