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