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