installers/full_install_osm.sh

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