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