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