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