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