installers/full_install_osm.sh

   1 #!/bin/bash
   2 #
   3 #   Licensed under the Apache License, Version 2.0 (the "License");
   4 #   you may not use this file except in compliance with the License.
   5 #   You may obtain a copy of the License at
   6 #
   7 #       http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 #   Unless required by applicable law or agreed to in writing, software
  10 #   distributed under the License is distributed on an "AS IS" BASIS,
  11 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 #   See the License for the specific language governing permissions and
  13 #   limitations under the License.
  14 #
  15
  16 function usage(){
  17     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
  18     echo -e "usage: $0 [OPTIONS]"
  19     echo -e "Install OSM from binaries or source code (by default, from binaries)"
  20     echo -e "  OPTIONS"
  21     echo -e "     -h / --help:    print this help"
  22     echo -e "     -y:             do not prompt for confirmation, assumes yes"
  23     echo -e "     -r <repo>:      use specified repository name for osm packages"
  24     echo -e "     -R <release>:   use specified release for osm binaries (deb packages, lxd images, ...)"
  25     echo -e "     -u <repo base>: use specified repository url for osm packages"
  26     echo -e "     -k <repo key>:  use specified repository public key url"
  27     echo -e "     -b <refspec>:   install OSM from source code using a specific branch (master, v2.0, ...) or tag"
  28     echo -e "                     -b master          (main dev branch)"
  29     echo -e "                     -b v2.0            (v2.0 branch)"
  30     echo -e "                     -b tags/v1.1.0     (a specific tag)"
  31     echo -e "                     ..."
  32     echo -e "     -a <apt proxy url>: use this apt proxy url when downloading apt packages (air-gapped installation)"
  33     echo -e "     -s <namespace>  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 "     -A <VCA apiproxy> use VCA/juju API proxy"
  38     echo -e "     --pla:          install the PLA module for placement support"
  39     echo -e "     --ng-sa:        install Airflow and Pushgateway to get VNF and NS status (experimental)"
  40     echo -e "     -m <MODULE>:    install OSM but only rebuild or pull the specified docker images (NG-UI, NBI, LCM, RO, MON, POL, PLA, KAFKA, MONGO, PROMETHEUS, PROMETHEUS-CADVISOR, KEYSTONE-DB, NONE)"
  41     echo -e "     -o <ADDON>:     ONLY (un)installs one of the addons (k8s_monitor, ng-sa)"
  42     echo -e "     -O <openrc file path/cloud name>: Install OSM to an OpenStack infrastructure. <openrc file/cloud name> is required. If a <cloud name> is used, the clouds.yaml file should be under ~/.config/openstack/ or /etc/openstack/"
  43     echo -e "     -N <openstack public network name/ID>: Public network name required to setup OSM to OpenStack"
  44     echo -e "     -f <path to SSH public key>: Public SSH key to use to deploy OSM to OpenStack"
  45     echo -e "     -F <path to cloud-init file>: Cloud-Init userdata file to deploy 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 "     --debug:        debug mode"
  56     echo -e "     --nocachelxdimages:  do not cache local lxd images, do not create cronjob for that cache (will save installation time, might affect instantiation time)"
  57     echo -e "     --cachelxdimages:  cache local lxd images, create cronjob for that cache (will make installation longer)"
  58     echo -e "     --nolxd:        do not install and configure LXD, allowing unattended installations (assumes LXD is already installed and confifured)"
  59     echo -e "     --nodocker:     do not install docker, do not initialize a swarm (assumes docker is already installed and a swarm has been initialized)"
  60     echo -e "     --nojuju:       do not juju, assumes already installed"
  61     echo -e "     --nodockerbuild:do not build docker images (use existing locally cached images)"
  62     echo -e "     --nohostports:  do not expose docker ports to host (useful for creating multiple instances of osm on the same host)"
  63     echo -e "     --nohostclient: do not install the osmclient"
  64     echo -e "     --uninstall:    uninstall OSM: remove the containers and delete NAT rules"
  65     echo -e "     --source:       install OSM from source code using the latest stable tag"
  66     echo -e "     --develop:      (deprecated, use '-b master') install OSM from source code using the master branch"
  67     echo -e "     --pullimages:   pull/run osm images from docker.io/opensourcemano"
  68     echo -e "     --k8s_monitor:  install the OSM kubernetes monitoring with prometheus and grafana"
  69     echo -e "     --volume:       create a VM volume when installing to OpenStack"
  70     echo -e "     --showopts:     print chosen options and exit (only for debugging)"
  71     echo -e "     --charmed:                   Deploy and operate OSM with Charms on k8s"
  72     echo -e "     [--bundle <bundle path>]:    Specify with which bundle to deploy OSM with charms (--charmed option)"
  73     echo -e "     [--k8s <kubeconfig path>]:   Specify with which kubernetes to deploy OSM with charms (--charmed option)"
  74     echo -e "     [--vca <name>]:              Specifies the name of the controller to use - The controller must be already bootstrapped (--charmed option)"
  75     echo -e "     [--small-profile]:           Do not install and configure LXD which aims to use only K8s Clouds (--charmed option)"
  76     echo -e "     [--lxd <yaml path>]:         Takes a YAML file as a parameter with the LXD Cloud information (--charmed option)"
  77     echo -e "     [--lxd-cred <yaml path>]:    Takes a YAML file as a parameter with the LXD Credentials information (--charmed option)"
  78     echo -e "     [--microstack]:              Installs microstack as a vim. (--charmed option)"
  79     echo -e "     [--overlay]:                 Add an overlay to override some defaults of the default bundle (--charmed option)"
  80     echo -e "     [--ha]:                      Installs High Availability bundle. (--charmed option)"
  81     echo -e "     [--tag]:                     Docker image tag. (--charmed option)"
  82     echo -e "     [--registry]:                Docker registry with optional credentials as user:pass@hostname:port (--charmed option)"
  83     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
  84 }
  85
  86 # takes a juju/accounts.yaml file and returns the password specific
  87 # for a controller. I wrote this using only bash tools to minimize
  88 # additions of other packages
  89 function parse_juju_password {
  90     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
  91     password_file="${HOME}/.local/share/juju/accounts.yaml"
  92     local controller_name=$1
  93     local s='[[:space:]]*' w='[a-zA-Z0-9_-]*' fs=$(echo @|tr @ '\034')
  94     sed -ne "s|^\($s\):|\1|" \
  95          -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
  96          -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p" $password_file |
  97     awk -F$fs -v controller=$controller_name '{
  98         indent = length($1)/2;
  99         vname[indent] = $2;
 100         for (i in vname) {if (i > indent) {delete vname[i]}}
 101         if (length($3) > 0) {
 102             vn=""; for (i=0; i<indent; i++) {vn=(vn)(vname[i])("_")}
 103             if (match(vn,controller) && match($2,"password")) {
 104                 printf("%s",$3);
 105             }
 106         }
 107     }'
 108     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 109 }
 110
 111 function set_vca_variables() {
 112     OSM_VCA_CLOUDNAME="lxd-cloud"
 113     [ -n "$OSM_VCA_HOST" ] && OSM_VCA_CLOUDNAME="localhost"
 114     if [ -z "$OSM_VCA_HOST" ]; then
 115         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`sg lxd -c "juju show-controller $OSM_NAMESPACE"|grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
 116         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_HOST=`juju show-controller $CONTROLLER_NAME |grep api-endpoints|awk -F\' '{print $2}'|awk -F\: '{print $1}'`
 117         [ -z "$OSM_VCA_HOST" ] && FATAL "Cannot obtain juju controller IP address"
 118     fi
 119     if [ -z "$OSM_VCA_SECRET" ]; then
 120         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $OSM_NAMESPACE)
 121         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_SECRET=$(parse_juju_password $CONTROLLER_NAME)
 122         [ -z "$OSM_VCA_SECRET" ] && FATAL "Cannot obtain juju secret"
 123     fi
 124     if [ -z "$OSM_VCA_PUBKEY" ]; then
 125         OSM_VCA_PUBKEY=$(cat $HOME/.local/share/juju/ssh/juju_id_rsa.pub)
 126         [ -z "$OSM_VCA_PUBKEY" ] && FATAL "Cannot obtain juju public key"
 127     fi
 128     if [ -z "$OSM_VCA_CACERT" ]; then
 129         [ -z "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $OSM_NAMESPACE '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
 130         [ -n "$CONTROLLER_NAME" ] && OSM_VCA_CACERT=$(juju controllers --format json | jq -r --arg controller $CONTROLLER_NAME '.controllers[$controller]["ca-cert"]' | base64 | tr -d \\n)
 131         [ -z "$OSM_VCA_CACERT" ] && FATAL "Cannot obtain juju CA certificate"
 132     fi
 133 }
 134
 135 function generate_secret() {
 136     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 137     head /dev/urandom | tr -dc A-Za-z0-9 | head -c 32
 138     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 139 }
 140
 141 function check_packages() {
 142     NEEDED_PACKAGES="$1"
 143     echo -e "Checking required packages: ${NEEDED_PACKAGES}"
 144     for PACKAGE in ${NEEDED_PACKAGES} ; do
 145         dpkg -L ${PACKAGE}
 146         if [ $? -ne 0 ]; then
 147             echo -e "Package ${PACKAGE} is not installed."
 148             echo -e "Updating apt-cache ..."
 149             sudo apt-get update
 150             echo -e "Installing ${PACKAGE} ..."
 151             sudo apt-get install -y ${PACKAGE} || FATAL "failed to install ${PACKAGE}"
 152         fi
 153     done
 154     echo -e "Required packages are present: ${NEEDED_PACKAGES}"
 155 }
 156
 157 function ask_user(){
 158     # ask to the user and parse a response among 'y', 'yes', 'n' or 'no'. Case insensitive
 159     # Params: $1 text to ask;   $2 Action by default, can be 'y' for yes, 'n' for no, other or empty for not allowed
 160     # Return: true(0) if user type 'yes'; false (1) if user type 'no'
 161     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 162     read -e -p "$1" USER_CONFIRMATION
 163     while true ; do
 164         [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'y' ] && return 0
 165         [ -z "$USER_CONFIRMATION" ] && [ "$2" == 'n' ] && return 1
 166         [ "${USER_CONFIRMATION,,}" == "yes" ] || [ "${USER_CONFIRMATION,,}" == "y" ] && return 0
 167         [ "${USER_CONFIRMATION,,}" == "no" ]  || [ "${USER_CONFIRMATION,,}" == "n" ] && return 1
 168         read -e -p "Please type 'yes' or 'no': " USER_CONFIRMATION
 169     done
 170     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 171 }
 172
 173 function install_osmclient(){
 174     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 175     CLIENT_RELEASE=${RELEASE#"-R "}
 176     CLIENT_REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
 177     CLIENT_REPOSITORY=${REPOSITORY#"-r "}
 178     CLIENT_REPOSITORY_BASE=${REPOSITORY_BASE#"-u "}
 179     key_location=$CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE/$CLIENT_REPOSITORY_KEY
 180     curl $key_location | sudo APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE=1 apt-key add -
 181     sudo add-apt-repository -y "deb [arch=amd64] $CLIENT_REPOSITORY_BASE/$CLIENT_RELEASE $CLIENT_REPOSITORY osmclient IM"
 182     sudo apt-get update
 183     sudo apt-get install -y python3-pip
 184     sudo -H LC_ALL=C python3 -m pip install -U pip
 185     sudo -H LC_ALL=C python3 -m pip install -U python-magic pyangbind verboselogs
 186     sudo apt-get install -y python3-osm-im python3-osmclient
 187     if [ -f /usr/lib/python3/dist-packages/osm_im/requirements.txt ]; then
 188         python3 -m pip install -r /usr/lib/python3/dist-packages/osm_im/requirements.txt
 189     fi
 190     if [ -f /usr/lib/python3/dist-packages/osmclient/requirements.txt ]; then
 191         sudo apt-get install -y libcurl4-openssl-dev libssl-dev libmagic1
 192         python3 -m pip install -r /usr/lib/python3/dist-packages/osmclient/requirements.txt
 193     fi
 194     [ -z "$INSTALL_LIGHTWEIGHT" ] && export OSM_HOSTNAME=`lxc list | awk '($2=="SO-ub"){print $6}'`
 195     [ -z "$INSTALL_LIGHTWEIGHT" ] && export OSM_RO_HOSTNAME=`lxc list | awk '($2=="RO"){print $6}'`
 196     echo -e "\nOSM client installed"
 197     if [ -z "$INSTALL_LIGHTWEIGHT" ]; then
 198         echo -e "You might be interested in adding the following OSM client env variables to your .bashrc file:"
 199         echo "     export OSM_HOSTNAME=${OSM_HOSTNAME}"
 200         echo "     export OSM_RO_HOSTNAME=${OSM_RO_HOSTNAME}"
 201     else
 202         echo -e "OSM client assumes that OSM host is running in localhost (127.0.0.1)."
 203         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:"
 204         echo "     export OSM_HOSTNAME=<OSM_host>"
 205     fi
 206     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 207     return 0
 208 }
 209
 210 function docker_login() {
 211     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 212     echo "Docker login"
 213     [ -z "${DEBUG_INSTALL}" ] || DEBUG "Docker registry user: ${DOCKER_REGISTRY_USER}"
 214     sg docker -c "docker login -u ${DOCKER_REGISTRY_USER} -p ${DOCKER_REGISTRY_PASSWORD} --password-stdin"
 215     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 216 }
 217
 218 function pull_docker_images() {
 219     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 220     echo "Pulling docker images"
 221     [ -n "${DOCKER_REGISTRY_URL}" ] && docker_login
 222
 223     echo "Pulling non-OSM docker images"
 224     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q KAFKA ; then
 225         sg docker -c "docker pull wurstmeister/zookeeper" || FATAL "cannot get zookeeper docker image"
 226         sg docker -c "docker pull wurstmeister/kafka:${KAFKA_TAG}" || FATAL "cannot get kafka docker image"
 227     fi
 228
 229     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS ; then
 230         sg docker -c "docker pull prom/prometheus:${PROMETHEUS_TAG}" || FATAL "cannot get prometheus docker image"
 231     fi
 232
 233     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q PROMETHEUS-CADVISOR ; then
 234         sg docker -c "docker pull google/cadvisor:${PROMETHEUS_CADVISOR_TAG}" || FATAL "cannot get prometheus cadvisor docker image"
 235     fi
 236
 237     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q GRAFANA ; then
 238         sg docker -c "docker pull grafana/grafana:${GRAFANA_TAG}" || FATAL "cannot get grafana docker image"
 239         sg docker -c "docker pull kiwigrid/k8s-sidecar:${KIWIGRID_K8S_SIDECAR_TAG}" || FATAL "cannot get kiwigrid k8s-sidecar docker image"
 240     fi
 241
 242     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q NBI || echo $TO_REBUILD | grep -q KEYSTONE-DB ; then
 243         sg docker -c "docker pull mariadb:${KEYSTONEDB_TAG}" || FATAL "cannot get keystone-db docker image"
 244     fi
 245
 246     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q RO ; then
 247         sg docker -c "docker pull mysql:5" || FATAL "cannot get mysql docker image"
 248     fi
 249
 250     echo "Pulling OSM docker images"
 251     for module in MON POL NBI KEYSTONE RO LCM NG-UI PLA osmclient Airflow; do
 252         module_lower=${module,,}
 253         if [ $module == "PLA" -a ! -n "$INSTALL_PLA" ]; then
 254             continue
 255         fi
 256         module_tag="${OSM_DOCKER_TAG}"
 257         if [ -n "${MODULE_DOCKER_TAG}" ] && echo $TO_REBUILD | grep -q $module ; then
 258             module_tag="${MODULE_DOCKER_TAG}"
 259         fi
 260         echo "Pulling ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module_lower}:${module_tag} docker image"
 261         sg docker -c "docker pull ${DOCKER_REGISTRY_URL}${DOCKER_USER}/${module_lower}:${module_tag}" || FATAL "cannot pull $module docker image"
 262     done
 263
 264     echo "Finished pulling docker images"
 265     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 266 }
 267
 268 function generate_docker_images() {
 269     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 270     echo "Generating docker images"
 271     _build_from=$COMMIT_ID
 272     [ -z "$_build_from" ] && _build_from="latest"
 273     echo "OSM Docker images generated from $_build_from"
 274     LWTEMPDIR="$(mktemp -d -q --tmpdir "installosmlight.XXXXXX")"
 275     trap 'rm -rf "${LWTEMPDIR}"' EXIT
 276     for module in MON POL NBI KEYSTONE RO LCM NG-UI PLA; do
 277         if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q ${module} ; then
 278             module_lower=${module,,}
 279             if [ $module == "PLA" -a ! -n "$INSTALL_PLA" ]; then
 280                 continue
 281             fi
 282             git -C ${LWTEMPDIR} clone https://osm.etsi.org/gerrit/osm/$module
 283             git -C ${LWTEMPDIR}/${module} checkout ${COMMIT_ID}
 284             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"
 285         fi
 286     done
 287     if [ -z "$TO_REBUILD" ] || echo $TO_REBUILD | grep -q osmclient; then
 288         BUILD_ARGS+=(--build-arg REPOSITORY="$REPOSITORY")
 289         BUILD_ARGS+=(--build-arg RELEASE="$RELEASE")
 290         BUILD_ARGS+=(--build-arg REPOSITORY_KEY="$REPOSITORY_KEY")
 291         BUILD_ARGS+=(--build-arg REPOSITORY_BASE="$REPOSITORY_BASE")
 292         sg docker -c "docker build -t ${DOCKER_USER}/osmclient ${BUILD_ARGS[@]} -f $OSM_DEVOPS/docker/osmclient ."
 293     fi
 294     echo "Finished generation of docker images"
 295     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 296 }
 297
 298 function cmp_overwrite() {
 299     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 300     file1="$1"
 301     file2="$2"
 302     if ! $(cmp "${file1}" "${file2}" >/dev/null 2>&1); then
 303         if [ -f "${file2}" ]; then
 304             ask_user "The file ${file2} already exists. Overwrite (y/N)? " n && cp -b ${file1} ${file2}
 305         else
 306             cp -b ${file1} ${file2}
 307         fi
 308     fi
 309     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 310 }
 311
 312 function generate_k8s_manifest_files() {
 313     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 314     #Kubernetes resources
 315     sudo cp -bR ${OSM_DEVOPS}/installers/docker/osm_pods $OSM_DOCKER_WORK_DIR
 316     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 317 }
 318
 319 function generate_docker_env_files() {
 320     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 321     echo "Doing a backup of existing env files"
 322     sudo cp $OSM_DOCKER_WORK_DIR/keystone-db.env{,~}
 323     sudo cp $OSM_DOCKER_WORK_DIR/keystone.env{,~}
 324     sudo cp $OSM_DOCKER_WORK_DIR/lcm.env{,~}
 325     sudo cp $OSM_DOCKER_WORK_DIR/mon.env{,~}
 326     sudo cp $OSM_DOCKER_WORK_DIR/nbi.env{,~}
 327     sudo cp $OSM_DOCKER_WORK_DIR/pol.env{,~}
 328     sudo cp $OSM_DOCKER_WORK_DIR/ro-db.env{,~}
 329     sudo cp $OSM_DOCKER_WORK_DIR/ro.env{,~}
 330     if [ -n "${INSTALL_NGSA}" ]; then
 331         sudo cp $OSM_DOCKER_WORK_DIR/ngsa.env{,~}
 332         sudo cp $OSM_DOCKER_WORK_DIR/webhook-translator.env{,~}
 333     fi
 334
 335     echo "Generating docker env files"
 336     # LCM
 337     if [ ! -f $OSM_DOCKER_WORK_DIR/lcm.env ]; then
 338         echo "OSMLCM_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 339     fi
 340
 341     if ! grep -Fq "OSMLCM_VCA_HOST" $OSM_DOCKER_WORK_DIR/lcm.env; then
 342         echo "OSMLCM_VCA_HOST=${OSM_VCA_HOST}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 343     else
 344         sudo sed -i "s|OSMLCM_VCA_HOST.*|OSMLCM_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/lcm.env
 345     fi
 346
 347     if ! grep -Fq "OSMLCM_VCA_SECRET" $OSM_DOCKER_WORK_DIR/lcm.env; then
 348         echo "OSMLCM_VCA_SECRET=${OSM_VCA_SECRET}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 349     else
 350         sudo sed -i "s|OSMLCM_VCA_SECRET.*|OSMLCM_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/lcm.env
 351     fi
 352
 353     if ! grep -Fq "OSMLCM_VCA_PUBKEY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 354         echo "OSMLCM_VCA_PUBKEY=${OSM_VCA_PUBKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 355     else
 356         sudo sed -i "s|OSMLCM_VCA_PUBKEY.*|OSMLCM_VCA_PUBKEY=${OSM_VCA_PUBKEY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 357     fi
 358
 359     if ! grep -Fq "OSMLCM_VCA_CACERT" $OSM_DOCKER_WORK_DIR/lcm.env; then
 360         echo "OSMLCM_VCA_CACERT=${OSM_VCA_CACERT}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 361     else
 362         sudo sed -i "s|OSMLCM_VCA_CACERT.*|OSMLCM_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 363     fi
 364
 365     if [ -n "$OSM_VCA_APIPROXY" ]; then
 366         if ! grep -Fq "OSMLCM_VCA_APIPROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 367             echo "OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 368         else
 369             sudo sed -i "s|OSMLCM_VCA_APIPROXY.*|OSMLCM_VCA_APIPROXY=${OSM_VCA_APIPROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 370         fi
 371     fi
 372
 373     if ! grep -Fq "OSMLCM_VCA_ENABLEOSUPGRADE" $OSM_DOCKER_WORK_DIR/lcm.env; then
 374         echo "# OSMLCM_VCA_ENABLEOSUPGRADE=false" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 375     fi
 376
 377     if ! grep -Fq "OSMLCM_VCA_APTMIRROR" $OSM_DOCKER_WORK_DIR/lcm.env; then
 378         echo "# OSMLCM_VCA_APTMIRROR=http://archive.ubuntu.com/ubuntu/" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 379     fi
 380
 381     if ! grep -Fq "OSMLCM_VCA_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env; then
 382         echo "OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 383     else
 384         sudo sed -i "s|OSMLCM_VCA_CLOUD.*|OSMLCM_VCA_CLOUD=${OSM_VCA_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 385     fi
 386
 387     if ! grep -Fq "OSMLCM_VCA_K8S_CLOUD" $OSM_DOCKER_WORK_DIR/lcm.env; then
 388         echo "OSMLCM_VCA_K8S_CLOUD=${OSM_VCA_K8S_CLOUDNAME}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 389     else
 390         sudo sed -i "s|OSMLCM_VCA_K8S_CLOUD.*|OSMLCM_VCA_K8S_CLOUD=${OSM_VCA_K8S_CLOUDNAME}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 391     fi
 392     if [ -n "${OSM_BEHIND_PROXY}" ]; then
 393         if ! grep -Fq "HTTP_PROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 394             echo "HTTP_PROXY=${HTTP_PROXY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 395         else
 396             sudo sed -i "s|HTTP_PROXY.*|HTTP_PROXY=${HTTP_PROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 397         fi
 398         if ! grep -Fq "HTTPS_PROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 399             echo "HTTPS_PROXY=${HTTPS_PROXY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 400         else
 401             sudo sed -i "s|HTTPS_PROXY.*|HTTPS_PROXY=${HTTPS_PROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 402         fi
 403         if ! grep -Fq "NO_PROXY" $OSM_DOCKER_WORK_DIR/lcm.env; then
 404             echo "NO_PROXY=${NO_PROXY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/lcm.env
 405         else
 406             sudo sed -i "s|NO_PROXY.*|NO_PROXY=${NO_PROXY}|g" $OSM_DOCKER_WORK_DIR/lcm.env
 407         fi
 408     fi
 409
 410     # RO
 411     MYSQL_ROOT_PASSWORD=$(generate_secret)
 412     if [ ! -f $OSM_DOCKER_WORK_DIR/ro-db.env ]; then
 413         echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/ro-db.env
 414     fi
 415     if [ ! -f $OSM_DOCKER_WORK_DIR/ro.env ]; then
 416         echo "RO_DB_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/ro.env
 417     fi
 418     if ! grep -Fq "OSMRO_DATABASE_COMMONKEY" $OSM_DOCKER_WORK_DIR/ro.env; then
 419         echo "OSMRO_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/ro.env
 420     fi
 421
 422     # Keystone
 423     KEYSTONE_DB_PASSWORD=$(generate_secret)
 424     SERVICE_PASSWORD=$(generate_secret)
 425     if [ ! -f $OSM_DOCKER_WORK_DIR/keystone-db.env ]; then
 426         echo "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/keystone-db.env
 427     fi
 428     if [ ! -f $OSM_DOCKER_WORK_DIR/keystone.env ]; then
 429         echo "ROOT_DB_PASSWORD=${MYSQL_ROOT_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/keystone.env
 430         echo "KEYSTONE_DB_PASSWORD=${KEYSTONE_DB_PASSWORD}" |sudo tee -a $OSM_DOCKER_WORK_DIR/keystone.env
 431         echo "SERVICE_PASSWORD=${SERVICE_PASSWORD}" |sudo tee -a $OSM_DOCKER_WORK_DIR/keystone.env
 432     fi
 433
 434     # NBI
 435     if [ ! -f $OSM_DOCKER_WORK_DIR/nbi.env ]; then
 436         echo "OSMNBI_AUTHENTICATION_SERVICE_PASSWORD=${SERVICE_PASSWORD}" |sudo tee $OSM_DOCKER_WORK_DIR/nbi.env
 437         echo "OSMNBI_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/nbi.env
 438     fi
 439
 440     # MON
 441     if [ ! -f $OSM_DOCKER_WORK_DIR/mon.env ]; then
 442         echo "OSMMON_KEYSTONE_SERVICE_PASSWORD=${SERVICE_PASSWORD}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 443         echo "OSMMON_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 444         echo "OSMMON_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/mon" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 445     fi
 446
 447     if ! grep -Fq "OS_NOTIFIER_URI" $OSM_DOCKER_WORK_DIR/mon.env; then
 448         echo "OS_NOTIFIER_URI=http://${OSM_DEFAULT_IP}:8662" |sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 449     else
 450         sudo sed -i "s|OS_NOTIFIER_URI.*|OS_NOTIFIER_URI=http://$OSM_DEFAULT_IP:8662|g" $OSM_DOCKER_WORK_DIR/mon.env
 451     fi
 452
 453     if ! grep -Fq "OSMMON_VCA_HOST" $OSM_DOCKER_WORK_DIR/mon.env; then
 454         echo "OSMMON_VCA_HOST=${OSM_VCA_HOST}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 455     else
 456         sudo sed -i "s|OSMMON_VCA_HOST.*|OSMMON_VCA_HOST=$OSM_VCA_HOST|g" $OSM_DOCKER_WORK_DIR/mon.env
 457     fi
 458
 459     if ! grep -Fq "OSMMON_VCA_SECRET" $OSM_DOCKER_WORK_DIR/mon.env; then
 460         echo "OSMMON_VCA_SECRET=${OSM_VCA_SECRET}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 461     else
 462         sudo sed -i "s|OSMMON_VCA_SECRET.*|OSMMON_VCA_SECRET=$OSM_VCA_SECRET|g" $OSM_DOCKER_WORK_DIR/mon.env
 463     fi
 464
 465     if ! grep -Fq "OSMMON_VCA_CACERT" $OSM_DOCKER_WORK_DIR/mon.env; then
 466         echo "OSMMON_VCA_CACERT=${OSM_VCA_CACERT}" | sudo tee -a $OSM_DOCKER_WORK_DIR/mon.env
 467     else
 468         sudo sed -i "s|OSMMON_VCA_CACERT.*|OSMMON_VCA_CACERT=${OSM_VCA_CACERT}|g" $OSM_DOCKER_WORK_DIR/mon.env
 469     fi
 470
 471     # POL
 472     if [ ! -f $OSM_DOCKER_WORK_DIR/pol.env ]; then
 473         echo "OSMPOL_SQL_DATABASE_URI=mysql://root:${MYSQL_ROOT_PASSWORD}@mysql:3306/pol" | sudo tee -a $OSM_DOCKER_WORK_DIR/pol.env
 474     fi
 475
 476     # NG-SA
 477     if [ -n "${INSTALL_NGSA}" ] && [ ! -f $OSM_DOCKER_WORK_DIR/ngsa.env ]; then
 478         echo "OSMMON_DATABASE_COMMONKEY=${OSM_DATABASE_COMMONKEY}" | sudo tee -a $OSM_DOCKER_WORK_DIR/ngsa.env
 479     fi
 480
 481     # Webhook-translator
 482     if [ -n "${INSTALL_NGSA}" ] && [ ! -f $OSM_DOCKER_WORK_DIR/webhook-translator.env ]; then
 483         echo "AIRFLOW_HOST=airflow-webserver" | sudo tee -a $OSM_DOCKER_WORK_DIR/webhook-translator.env
 484         echo "AIRFLOW_PORT=8080" | sudo tee -a $OSM_DOCKER_WORK_DIR/webhook-translator.env
 485         echo "AIRFLOW_USER=admin" | sudo tee -a $OSM_DOCKER_WORK_DIR/webhook-translator.env
 486         echo "AIRFLOW_PASS=admin" | sudo tee -a $OSM_DOCKER_WORK_DIR/webhook-translator.env
 487     fi
 488
 489     echo "Finished generation of docker env files"
 490     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 491 }
 492
 493 #creates secrets from env files which will be used by containers
 494 function kube_secrets(){
 495     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 496     kubectl create ns $OSM_NAMESPACE
 497     kubectl create secret generic lcm-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/lcm.env
 498     kubectl create secret generic mon-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/mon.env
 499     kubectl create secret generic nbi-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/nbi.env
 500     kubectl create secret generic ro-db-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/ro-db.env
 501     kubectl create secret generic ro-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/ro.env
 502     kubectl create secret generic keystone-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/keystone.env
 503     kubectl create secret generic pol-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/pol.env
 504     if [ -n "${INSTALL_NGSA}" ]; then
 505         kubectl create secret generic ngsa-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/ngsa.env
 506         kubectl create secret generic webhook-translator-secret -n $OSM_NAMESPACE --from-env-file=$OSM_DOCKER_WORK_DIR/webhook-translator.env
 507     fi
 508     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 509 }
 510
 511 #deploys osm pods and services
 512 function deploy_osm_services() {
 513     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 514     kubectl apply -n $OSM_NAMESPACE -f $OSM_K8S_WORK_DIR
 515     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 516 }
 517
 518 #deploy charmed services
 519 function deploy_charmed_services() {
 520     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 521     juju add-model $OSM_NAMESPACE $OSM_VCA_K8S_CLOUDNAME
 522     juju deploy ch:mongodb-k8s -m $OSM_NAMESPACE
 523     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 524 }
 525
 526 function deploy_osm_pla_service() {
 527     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 528     # corresponding to deploy_osm_services
 529     kubectl apply -n $OSM_NAMESPACE -f $OSM_DOCKER_WORK_DIR/osm_pla
 530     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 531 }
 532
 533 function install_osm_ngsa_service() {
 534     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 535     $OSM_DEVOPS/installers/install_ngsa.sh -d ${OSM_HELM_WORK_DIR} -D ${OSM_DEVOPS} -t ${OSM_DOCKER_TAG} ${DEBUG_INSTALL} || \
 536     FATAL_TRACK install_osm_ngsa_service "install_ngsa.sh failed"
 537     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 538 }
 539
 540 function parse_yaml() {
 541     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 542     TAG=$1
 543     shift
 544     services=$@
 545     for module in $services; do
 546         if [ "$module" == "pla" ]; then
 547             if [ -n "$INSTALL_PLA" ]; then
 548                 echo "Updating K8s manifest file from opensourcemano\/pla:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/pla:${TAG}"
 549                 sudo sed -i "s#opensourcemano/pla:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/pla:${TAG}#g" ${OSM_DOCKER_WORK_DIR}/osm_pla/pla.yaml
 550             fi
 551         else
 552             image=${module}
 553             if [ "$module" == "ng-prometheus" ]; then
 554                 image="prometheus"
 555             elif [ "$module" == "ng-mon" ]; then
 556                 image="mon"
 557             fi
 558             echo "Updating K8s manifest file from opensourcemano\/${image}:.* to ${DOCKER_REGISTRY_URL}${DOCKER_USER}\/${image}:${TAG}"
 559             sudo sed -i "s#opensourcemano/${image}:.*#${DOCKER_REGISTRY_URL}${DOCKER_USER}/${image}:${TAG}#g" ${OSM_K8S_WORK_DIR}/${module}.yaml
 560         fi
 561     done
 562     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 563 }
 564
 565 function update_manifest_files() {
 566     osm_services="nbi lcm ro pol mon ng-mon ng-ui keystone pla prometheus ng-prometheus"
 567     list_of_services=""
 568     for module in $osm_services; do
 569         module_upper="${module^^}"
 570         if ! echo $TO_REBUILD | grep -q $module_upper ; then
 571             list_of_services="$list_of_services $module"
 572         fi
 573     done
 574     if [ ! "$OSM_DOCKER_TAG" == "13" ]; then
 575         parse_yaml $OSM_DOCKER_TAG $list_of_services
 576     fi
 577     if [ -n "$MODULE_DOCKER_TAG" ]; then
 578         parse_yaml $MODULE_DOCKER_TAG $list_of_services_to_rebuild
 579     fi
 580     # The manifest for prometheus is prometheus.yaml or ng-prometheus.yaml, depending on the installation option
 581     # If NG-SA is installed, it will include ng-mon (only mon-dashboarder), ng-prometheus and webhook translator. It won't include pol, mon and prometheus
 582     if [ -n "$INSTALL_NGSA" ]; then
 583         sudo rm -f ${OSM_K8S_WORK_DIR}/prometheus.yaml
 584         sudo rm -f ${OSM_K8S_WORK_DIR}/mon.yaml
 585         sudo rm -f ${OSM_K8S_WORK_DIR}/pol.yaml
 586     else
 587         sudo rm -f ${OSM_K8S_WORK_DIR}/ng-mon.yaml
 588         sudo rm -f ${OSM_K8S_WORK_DIR}/ng-prometheus.yaml
 589         sudo rm -f ${OSM_K8S_WORK_DIR}/webhook-translator.yaml
 590     fi
 591     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 592 }
 593
 594 function namespace_vol() {
 595     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 596     # List of services with a volume mounted in path /var/lib/osm
 597     osm_services="mysql"
 598     for osm in $osm_services; do
 599         if [ -f "$OSM_K8S_WORK_DIR/$osm.yaml" ] ; then
 600             sudo sed -i "s#path: /var/lib/osm#path: $OSM_NAMESPACE_VOL#g" $OSM_K8S_WORK_DIR/$osm.yaml
 601         fi
 602     done
 603     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 604 }
 605
 606 function add_local_k8scluster() {
 607     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 608     /usr/bin/osm --all-projects vim-create \
 609       --name _system-osm-vim \
 610       --account_type dummy \
 611       --auth_url http://dummy \
 612       --user osm --password osm --tenant osm \
 613       --description "dummy" \
 614       --config '{management_network_name: mgmt}'
 615     /usr/bin/osm --all-projects k8scluster-add \
 616       --creds ${HOME}/.kube/config \
 617       --vim _system-osm-vim \
 618       --k8s-nets '{"net1": null}' \
 619       --version '1.15' \
 620       --description "OSM Internal Cluster" \
 621       _system-osm-k8s
 622     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 623 }
 624
 625 function configure_apt_proxy() {
 626     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 627     OSM_APT_PROXY=$1
 628     OSM_APT_PROXY_FILE="/etc/apt/apt.conf.d/osm-apt"
 629     echo "Configuring apt proxy in file ${OSM_APT_PROXY_FILE}"
 630     if [ ! -f ${OSM_APT_PROXY_FILE} ]; then
 631         sudo bash -c "cat <<EOF > ${OSM_APT_PROXY}
 632 Acquire::http { Proxy \"${OSM_APT_PROXY}\"; }
 633 EOF"
 634     else
 635         sudo sed -i "s|Proxy.*|Proxy \"${OSM_APT_PROXY}\"; }|" ${OSM_APT_PROXY_FILE}
 636     fi
 637     sudo apt-get update || FATAL "Configured apt proxy, but couldn't run 'apt-get update'. Check ${OSM_APT_PROXY_FILE}"
 638     track prereq apt_proxy_configured_ok
 639     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 640 }
 641
 642 function ask_proceed() {
 643     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 644
 645     [ -z "$ASSUME_YES" ] && ! ask_user "The installation will do the following
 646     1. Install and configure LXD
 647     2. Install juju
 648     3. Install docker CE
 649     4. Disable swap space
 650     5. Install and initialize Kubernetes
 651     as pre-requirements.
 652     Do you want to proceed (Y/n)? " y && echo "Cancelled!" && exit 1
 653
 654     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 655 }
 656
 657 function check_osm_behind_proxy() {
 658     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 659
 660     export OSM_BEHIND_PROXY=""
 661     export OSM_PROXY_ENV_VARIABLES=""
 662     [ -n "${http_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "http_proxy=${http_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} http_proxy"
 663     [ -n "${https_proxy}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${https_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} https_proxy"
 664     [ -n "${HTTP_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "HTTP_PROXY=${HTTP_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTP_PROXY"
 665     [ -n "${HTTPS_PROXY}" ] && OSM_BEHIND_PROXY="y" && echo "https_proxy=${HTTPS_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} HTTPS_PROXY"
 666     [ -n "${no_proxy}" ] && echo "no_proxy=${no_proxy}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} no_proxy"
 667     [ -n "${NO_PROXY}" ] && echo "NO_PROXY=${NO_PROXY}" && OSM_PROXY_ENV_VARIABLES="${OSM_PROXY_ENV_VARIABLES} NO_PROXY"
 668
 669     echo "OSM_BEHIND_PROXY=${OSM_BEHIND_PROXY}"
 670     echo "OSM_PROXY_ENV_VARIABLES=${OSM_PROXY_ENV_VARIABLES}"
 671
 672     if [ -n "${OSM_BEHIND_PROXY}" ]; then
 673         [ -z "$ASSUME_YES" ] && ! ask_user "
 674 The following env variables have been found for the current user:
 675 ${OSM_PROXY_ENV_VARIABLES}.
 676
 677 This suggests that this machine is behind a proxy and a special configuration is required.
 678 The installer will install Docker CE, LXD and Juju to work behind a proxy using those
 679 env variables.
 680
 681 Take into account that the installer uses apt, curl, wget, docker, lxd, juju and snap.
 682 Depending on the program, the env variables to work behind a proxy might be different
 683 (e.g. http_proxy vs HTTP_PROXY).
 684
 685 For that reason, it is strongly recommended that at least http_proxy, https_proxy, HTTP_PROXY
 686 and HTTPS_PROXY are defined.
 687
 688 Finally, some of the programs (apt, snap) those programs are run as sudoer, requiring that
 689 those env variables are also set for root user. If you are not sure whether those variables
 690 are configured for the root user, you can stop the installation now.
 691
 692 Do you want to proceed with the installation (Y/n)? " y && echo "Cancelled!" && exit 1
 693     else
 694         echo "This machine is not behind a proxy"
 695     fi
 696
 697     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 698 }
 699
 700 function find_devops_folder() {
 701     if [ -z "$OSM_DEVOPS" ]; then
 702         if [ -n "$TEST_INSTALLER" ]; then
 703             echo -e "\nUsing local devops repo for OSM installation"
 704             OSM_DEVOPS="$(dirname $(realpath $(dirname $0)))"
 705         else
 706             echo -e "\nCreating temporary dir for OSM installation"
 707             OSM_DEVOPS="$(mktemp -d -q --tmpdir "installosm.XXXXXX")"
 708             trap 'rm -rf "$OSM_DEVOPS"' EXIT
 709             git clone https://osm.etsi.org/gerrit/osm/devops.git $OSM_DEVOPS
 710         fi
 711     fi
 712 }
 713
 714 function install_osm() {
 715     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 716
 717     trap ctrl_c INT
 718
 719     # TODO: move this under start
 720     [ -n "$DOCKER_REGISTRY_URL" ] && parse_docker_registry_url
 721
 722     check_osm_behind_proxy
 723     track checks proxy_ok
 724
 725     check_packages "git wget curl tar snapd"
 726
 727     sudo snap install jq || FATAL "Could not install jq (snap package). Make sure that snap works"
 728
 729     find_devops_folder
 730
 731     track start release $RELEASE none none docker_tag $OSM_DOCKER_TAG none none installation_type $OSM_INSTALLATION_TYPE none none
 732
 733     track checks checkingroot_ok
 734     [ "$USER" == "root" ] && FATAL "You are running the installer as root. The installer is prepared to be executed as a normal user with sudo privileges."
 735     track checks noroot_ok
 736
 737     ask_proceed
 738     track checks proceed_ok
 739
 740     echo "Installing OSM"
 741
 742     echo "Determining IP address of the interface with the default route"
 743     [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(ip route list|awk '$1=="default" {print $5; exit}')
 744     [ -z "$OSM_DEFAULT_IF" ] && OSM_DEFAULT_IF=$(route -n |awk '$1~/^0.0.0.0/ {print $8; exit}')
 745     [ -z "$OSM_DEFAULT_IF" ] && FATAL "Not possible to determine the interface with the default route 0.0.0.0"
 746     OSM_DEFAULT_IP=`ip -o -4 a s ${OSM_DEFAULT_IF} |awk '{split($4,a,"/"); print a[1]; exit}'`
 747     [ -z "$OSM_DEFAULT_IP" ] && FATAL "Not possible to determine the IP address of the interface with the default route"
 748
 749     # configure apt proxy
 750     [ -n "$APT_PROXY_URL" ] && configure_apt_proxy $APT_PROXY_URL
 751
 752     # if no host is passed in, we need to install lxd/juju, unless explicilty asked not to
 753     if [ -z "$OSM_VCA_HOST" ] && [ -z "$INSTALL_NOLXD" ] && [ -z "$LXD_CLOUD_FILE" ]; then
 754         LXD_INSTALL_OPTS="-D ${OSM_DEVOPS} -i ${OSM_DEFAULT_IF} ${DEBUG_INSTALL}"
 755         [ -n "${OSM_BEHIND_PROXY}" ] && LXD_INSTALL_OPTS="${LXD_INSTALL_OPTS} -P"
 756         $OSM_DEVOPS/installers/install_lxd.sh ${LXD_INSTALL_OPTS} || FATAL_TRACK lxd "install_lxd.sh failed"
 757     fi
 758
 759     track prereq prereqok_ok
 760
 761     if [ ! -n "$INSTALL_NODOCKER" ]; then
 762         DOCKER_CE_OPTS="-D ${OSM_DEVOPS} ${DEBUG_INSTALL}"
 763         [ -n "${DOCKER_PROXY_URL}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -p ${DOCKER_PROXY_URL}"
 764         [ -n "${OSM_BEHIND_PROXY}" ] && DOCKER_CE_OPTS="${DOCKER_CE_OPTS} -P"
 765         $OSM_DEVOPS/installers/install_docker_ce.sh ${DOCKER_CE_OPTS} || FATAL_TRACK docker_ce "install_docker_ce.sh failed"
 766     fi
 767
 768     track docker_ce docker_ce_ok
 769
 770     echo "Creating folders for installation"
 771     [ ! -d "$OSM_DOCKER_WORK_DIR" ] && sudo mkdir -p $OSM_DOCKER_WORK_DIR
 772     [ ! -d "$OSM_DOCKER_WORK_DIR/osm_pla" -a -n "$INSTALL_PLA" ] && sudo mkdir -p $OSM_DOCKER_WORK_DIR/osm_pla
 773     sudo cp -b $OSM_DEVOPS/installers/docker/cluster-config.yaml $OSM_DOCKER_WORK_DIR/cluster-config.yaml
 774
 775     $OSM_DEVOPS/installers/install_kubeadm_cluster.sh -i ${OSM_DEFAULT_IP} -d ${OSM_DOCKER_WORK_DIR} -D ${OSM_DEVOPS} ${DEBUG_INSTALL} || \
 776     FATAL_TRACK k8scluster "install_kubeadm_cluster.sh failed"
 777     track k8scluster k8scluster_ok
 778
 779     JUJU_OPTS="-D ${OSM_DEVOPS} -s ${OSM_NAMESPACE} -i ${OSM_DEFAULT_IP} ${DEBUG_INSTALL} ${INSTALL_NOJUJU} ${INSTALL_CACHELXDIMAGES}"
 780     [ -n "${OSM_VCA_HOST}" ] && JUJU_OPTS="$JUJU_OPTS -H ${OSM_VCA_HOST}"
 781     [ -n "${LXD_CLOUD_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -l ${LXD_CLOUD_FILE}"
 782     [ -n "${LXD_CRED_FILE}" ] && JUJU_OPTS="$JUJU_OPTS -L ${LXD_CRED_FILE}"
 783     [ -n "${CONTROLLER_NAME}" ] && JUJU_OPTS="$JUJU_OPTS -K ${CONTROLLER_NAME}"
 784     [ -n "${OSM_BEHIND_PROXY}" ] && JUJU_OPTS="${JUJU_OPTS} -P"
 785     $OSM_DEVOPS/installers/install_juju.sh ${JUJU_OPTS} || FATAL_TRACK juju "install_juju.sh failed"
 786     set_vca_variables
 787     track juju juju_ok
 788
 789     if [ -z "$OSM_DATABASE_COMMONKEY" ]; then
 790         OSM_DATABASE_COMMONKEY=$(generate_secret)
 791         [ -z "OSM_DATABASE_COMMONKEY" ] && FATAL "Cannot generate common db secret"
 792     fi
 793
 794     # Deploy OSM services
 795     [ -z "$DOCKER_NOBUILD" ] && pull_docker_images
 796     [ -z "$DOCKER_NOBUILD" ] && [ -z "$PULL_IMAGES" ] && generate_docker_images
 797     track docker_images docker_images_ok
 798
 799     generate_k8s_manifest_files
 800     track osm_files manifest_files_ok
 801     generate_docker_env_files
 802     track osm_files env_files_ok
 803
 804     deploy_charmed_services
 805     track deploy_osm deploy_charmed_services_ok
 806     kube_secrets
 807     track deploy_osm kube_secrets_ok
 808     update_manifest_files
 809     track deploy_osm update_manifest_files_ok
 810     namespace_vol
 811     track deploy_osm namespace_vol_ok
 812     deploy_osm_services
 813     track deploy_osm deploy_osm_services_k8s_ok
 814     if [ -n "$INSTALL_PLA" ]; then
 815         # optional PLA install
 816         deploy_osm_pla_service
 817         track deploy_osm deploy_osm_pla_ok
 818     fi
 819     if [ -n "$INSTALL_K8S_MONITOR" ]; then
 820         # install OSM MONITORING
 821         install_k8s_monitoring
 822         track deploy_osm install_k8s_monitoring_ok
 823     fi
 824     if [ -n "$INSTALL_NGSA" ]; then
 825         # optional PLA install
 826         install_osm_ngsa_service
 827         track deploy_osm install_osm_ngsa_ok
 828     fi
 829
 830     [ -z "$INSTALL_NOHOSTCLIENT" ] && install_osmclient
 831     track osmclient osmclient_ok
 832
 833     echo -e "Checking OSM health state..."
 834     $OSM_DEVOPS/installers/osm_health.sh -s ${OSM_NAMESPACE} -k || \
 835     (echo -e "OSM is not healthy, but will probably converge to a healthy state soon." && \
 836     echo -e "Check OSM status with: kubectl -n ${OSM_NAMESPACE} get all" && \
 837     track healthchecks osm_unhealthy didnotconverge)
 838     track healthchecks after_healthcheck_ok
 839
 840     add_local_k8scluster
 841     track final_ops add_local_k8scluster_ok
 842
 843     arrange_docker_default_network_policy
 844
 845     wget -q -O- https://osm-download.etsi.org/ftp/osm-13.0-thirteen/README2.txt &> /dev/null
 846     track end
 847     sudo find /etc/osm
 848     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 849     return 0
 850 }
 851
 852 function install_to_openstack() {
 853     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 854
 855     if [ -z "$2" ]; then
 856         FATAL "OpenStack installer requires a valid external network name"
 857     fi
 858
 859     # Install Pip for Python3
 860     sudo apt install -y python3-pip python3-venv
 861     sudo -H LC_ALL=C python3 -m pip install -U pip
 862
 863     # Create a venv to avoid conflicts with the host installation
 864     python3 -m venv $OPENSTACK_PYTHON_VENV
 865
 866     source $OPENSTACK_PYTHON_VENV/bin/activate
 867
 868     # Install Ansible, OpenStack client and SDK, latest openstack version supported is Train
 869     python -m pip install -U wheel
 870     python -m pip install -U "python-openstackclient<=4.0.2" "openstacksdk>=0.12.0,<=0.36.2" "ansible>=2.10,<2.11"
 871
 872     # Install the Openstack cloud module (ansible>=2.10)
 873     ansible-galaxy collection install openstack.cloud
 874
 875     export ANSIBLE_CONFIG="$OSM_DEVOPS/installers/openstack/ansible.cfg"
 876
 877     OSM_INSTALLER_ARGS="${REPO_ARGS[@]}"
 878
 879     ANSIBLE_VARS="external_network_name=$2 setup_volume=$3 server_name=$OPENSTACK_VM_NAME"
 880
 881     if [ -n "$OPENSTACK_SSH_KEY_FILE" ]; then
 882         ANSIBLE_VARS+=" key_file=$OPENSTACK_SSH_KEY_FILE"
 883     fi
 884
 885     if [ -n "$OPENSTACK_USERDATA_FILE" ]; then
 886         ANSIBLE_VARS+=" userdata_file=$OPENSTACK_USERDATA_FILE"
 887     fi
 888
 889     # Execute the Ansible playbook based on openrc or clouds.yaml
 890     if [ -e "$1" ]; then
 891         . $1
 892         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 893         $OSM_DEVOPS/installers/openstack/site.yml
 894     else
 895         ansible-playbook -e installer_args="\"$OSM_INSTALLER_ARGS\"" -e "$ANSIBLE_VARS" \
 896         -e cloud_name=$1 $OSM_DEVOPS/installers/openstack/site.yml
 897     fi
 898
 899     # Exit from venv
 900     deactivate
 901
 902     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 903     return 0
 904 }
 905
 906 function arrange_docker_default_network_policy() {
 907     echo -e "Fixing firewall so docker and LXD can share the same host without affecting each other."
 908     sudo iptables -I DOCKER-USER -j ACCEPT
 909     sudo iptables-save | sudo tee /etc/iptables/rules.v4
 910     sudo ip6tables-save | sudo tee /etc/iptables/rules.v6
 911 }
 912
 913 function install_k8s_monitoring() {
 914     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 915     # install OSM monitoring
 916     sudo chmod +x $OSM_DEVOPS/installers/k8s/*.sh
 917     sudo $OSM_DEVOPS/installers/k8s/install_osm_k8s_monitoring.sh || FATAL_TRACK install_k8s_monitoring "k8s/install_osm_k8s_monitoring.sh failed"
 918     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 919 }
 920
 921 function dump_vars(){
 922     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 923     echo "APT_PROXY_URL=$APT_PROXY_URL"
 924     echo "DEVELOP=$DEVELOP"
 925     echo "DEBUG_INSTALL=$DEBUG_INSTALL"
 926     echo "DOCKER_NOBUILD=$DOCKER_NOBUILD"
 927     echo "DOCKER_PROXY_URL=$DOCKER_PROXY_URL"
 928     echo "DOCKER_REGISTRY_URL=$DOCKER_REGISTRY_URL"
 929     echo "DOCKER_USER=$DOCKER_USER"
 930     echo "INSTALL_CACHELXDIMAGES=$INSTALL_CACHELXDIMAGES"
 931     echo "INSTALL_FROM_SOURCE=$INSTALL_FROM_SOURCE"
 932     echo "INSTALL_K8S_MONITOR=$INSTALL_K8S_MONITOR"
 933     echo "INSTALL_LIGHTWEIGHT=$INSTALL_LIGHTWEIGHT"
 934     echo "INSTALL_LXD=$INSTALL_LXD"
 935     echo "INSTALL_NGSA=$INSTALL_NGSA"
 936     echo "INSTALL_NODOCKER=$INSTALL_NODOCKER"
 937     echo "INSTALL_NOJUJU=$INSTALL_NOJUJU"
 938     echo "INSTALL_NOLXD=$INSTALL_NOLXD"
 939     echo "INSTALL_ONLY=$INSTALL_ONLY"
 940     echo "INSTALL_PLA=$INSTALL_PLA"
 941     echo "INSTALL_TO_OPENSTACK=$INSTALL_TO_OPENSTACK"
 942     echo "INSTALL_VIMEMU=$INSTALL_VIMEMU"
 943     echo "NO_HOST_PORTS=$NO_HOST_PORTS"
 944     echo "OPENSTACK_PUBLIC_NET_NAME=$OPENSTACK_PUBLIC_NET_NAME"
 945     echo "OPENSTACK_OPENRC_FILE_OR_CLOUD=$OPENSTACK_OPENRC_FILE_OR_CLOUD"
 946     echo "OPENSTACK_ATTACH_VOLUME=$OPENSTACK_ATTACH_VOLUME"
 947     echo "OPENSTACK_SSH_KEY_FILE"="$OPENSTACK_SSH_KEY_FILE"
 948     echo "OPENSTACK_USERDATA_FILE"="$OPENSTACK_USERDATA_FILE"
 949     echo "OPENSTACK_VM_NAME"="$OPENSTACK_VM_NAME"
 950     echo "OSM_DEVOPS=$OSM_DEVOPS"
 951     echo "OSM_DOCKER_TAG=$OSM_DOCKER_TAG"
 952     echo "OSM_DOCKER_WORK_DIR=$OSM_DOCKER_WORK_DIR"
 953     echo "OSM_HELM_WORK_DIR=$OSM_HELM_WORK_DIR"
 954     echo "OSM_K8S_WORK_DIR=$OSM_K8S_WORK_DIR"
 955     echo "OSM_NAMESPACE=$OSM_NAMESPACE"
 956     echo "OSM_VCA_HOST=$OSM_VCA_HOST"
 957     echo "OSM_VCA_PUBKEY=$OSM_VCA_PUBKEY"
 958     echo "OSM_VCA_SECRET=$OSM_VCA_SECRET"
 959     echo "OSM_WORK_DIR=$OSM_WORK_DIR"
 960     echo "PULL_IMAGES=$PULL_IMAGES"
 961     echo "RECONFIGURE=$RECONFIGURE"
 962     echo "RELEASE=$RELEASE"
 963     echo "REPOSITORY=$REPOSITORY"
 964     echo "REPOSITORY_BASE=$REPOSITORY_BASE"
 965     echo "REPOSITORY_KEY=$REPOSITORY_KEY"
 966     echo "SHOWOPTS=$SHOWOPTS"
 967     echo "TEST_INSTALLER=$TEST_INSTALLER"
 968     echo "TO_REBUILD=$TO_REBUILD"
 969     echo "UNINSTALL=$UNINSTALL"
 970     echo "UPDATE=$UPDATE"
 971     echo "Install from specific refspec (-b): $COMMIT_ID"
 972     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 973 }
 974
 975 function parse_docker_registry_url() {
 976     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 977     DOCKER_REGISTRY_USER=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[1]}')
 978     DOCKER_REGISTRY_PASSWORD=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); split(a[1],b,":"); print b[2]}')
 979     DOCKER_REGISTRY_URL=$(echo "$DOCKER_REGISTRY_URL" | awk '{split($1,a,"@"); print a[2]}')
 980     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 981 }
 982
 983 function ctrl_c() {
 984     [ -z "${DEBUG_INSTALL}" ] || DEBUG beginning of function
 985     echo "** Trapped CTRL-C"
 986     FATAL "User stopped the installation"
 987     [ -z "${DEBUG_INSTALL}" ] || DEBUG end of function
 988 }
 989
 990 UNINSTALL=""
 991 DEVELOP=""
 992 UPDATE=""
 993 RECONFIGURE=""
 994 TEST_INSTALLER=""
 995 INSTALL_LXD=""
 996 SHOWOPTS=""
 997 COMMIT_ID=""
 998 ASSUME_YES=""
 999 APT_PROXY_URL=""
1000 INSTALL_FROM_SOURCE=""
1001 DEBUG_INSTALL=""
1002 RELEASE="ReleaseTEN"
1003 REPOSITORY="stable"
1004 INSTALL_K8S_MONITOR=""
1005 INSTALL_NGSA=""
1006 INSTALL_PLA=""
1007 INSTALL_VIMEMU=""
1008 LXD_REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/lxd"
1009 LXD_REPOSITORY_PATH=""
1010 INSTALL_LIGHTWEIGHT="y"
1011 INSTALL_TO_OPENSTACK=""
1012 OPENSTACK_OPENRC_FILE_OR_CLOUD=""
1013 OPENSTACK_PUBLIC_NET_NAME=""
1014 OPENSTACK_ATTACH_VOLUME="false"
1015 OPENSTACK_SSH_KEY_FILE=""
1016 OPENSTACK_USERDATA_FILE=""
1017 OPENSTACK_VM_NAME="server-osm"
1018 OPENSTACK_PYTHON_VENV="$HOME/.virtual-envs/osm"
1019 INSTALL_ONLY=""
1020 TO_REBUILD=""
1021 INSTALL_NOLXD=""
1022 INSTALL_NODOCKER=""
1023 INSTALL_NOJUJU=""
1024 INSTALL_NOHOSTCLIENT=""
1025 INSTALL_CACHELXDIMAGES=""
1026 OSM_DEVOPS=
1027 OSM_VCA_HOST=
1028 OSM_VCA_SECRET=
1029 OSM_VCA_PUBKEY=
1030 OSM_VCA_CLOUDNAME="localhost"
1031 OSM_VCA_K8S_CLOUDNAME="k8scloud"
1032 OSM_NAMESPACE=osm
1033 NO_HOST_PORTS=""
1034 DOCKER_NOBUILD=""
1035 REPOSITORY_KEY="OSM%20ETSI%20Release%20Key.gpg"
1036 REPOSITORY_BASE="https://osm-download.etsi.org/repository/osm/debian"
1037 OSM_WORK_DIR="/etc/osm"
1038 OSM_DOCKER_WORK_DIR="${OSM_WORK_DIR}/docker"
1039 OSM_K8S_WORK_DIR="${OSM_DOCKER_WORK_DIR}/osm_pods"
1040 OSM_HELM_WORK_DIR="${OSM_WORK_DIR}/helm"
1041 OSM_HOST_VOL="/var/lib/osm"
1042 OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_NAMESPACE}"
1043 OSM_DOCKER_TAG=latest
1044 DOCKER_USER=opensourcemano
1045 PULL_IMAGES="y"
1046 KAFKA_TAG=2.11-1.0.2
1047 KIWIGRID_K8S_SIDECAR_TAG="1.15.6"
1048 PROMETHEUS_TAG=v2.28.1
1049 GRAFANA_TAG=8.1.1
1050 PROMETHEUS_NODE_EXPORTER_TAG=0.18.1
1051 PROMETHEUS_CADVISOR_TAG=latest
1052 KEYSTONEDB_TAG=10
1053 OSM_DATABASE_COMMONKEY=
1054 ELASTIC_VERSION=6.4.2
1055 ELASTIC_CURATOR_VERSION=5.5.4
1056 POD_NETWORK_CIDR=10.244.0.0/16
1057 K8S_MANIFEST_DIR="/etc/kubernetes/manifests"
1058 RE_CHECK='^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
1059 DOCKER_REGISTRY_URL=
1060 DOCKER_PROXY_URL=
1061 MODULE_DOCKER_TAG=
1062 OSM_INSTALLATION_TYPE="Default"
1063
1064 while getopts ":a:b:r:n:k:u:R:D:o:O:m:N:H:S:s:t:U:P:A:l:L:K:d:p:T:f:F:-: hy" o; do
1065     case "${o}" in
1066         a)
1067             APT_PROXY_URL=${OPTARG}
1068             ;;
1069         b)
1070             COMMIT_ID=${OPTARG}
1071             PULL_IMAGES=""
1072             ;;
1073         r)
1074             REPOSITORY="${OPTARG}"
1075             REPO_ARGS+=(-r "$REPOSITORY")
1076             ;;
1077         k)
1078             REPOSITORY_KEY="${OPTARG}"
1079             REPO_ARGS+=(-k "$REPOSITORY_KEY")
1080             ;;
1081         u)
1082             REPOSITORY_BASE="${OPTARG}"
1083             REPO_ARGS+=(-u "$REPOSITORY_BASE")
1084             ;;
1085         R)
1086             RELEASE="${OPTARG}"
1087             REPO_ARGS+=(-R "$RELEASE")
1088             ;;
1089         D)
1090             OSM_DEVOPS="${OPTARG}"
1091             ;;
1092         o)
1093             INSTALL_ONLY="y"
1094             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1095             [ "${OPTARG}" == "ng-sa" ] && INSTALL_NGSA="y" && continue
1096             ;;
1097         O)
1098             INSTALL_TO_OPENSTACK="y"
1099             if [ -n "${OPTARG}" ]; then
1100                 OPENSTACK_OPENRC_FILE_OR_CLOUD="${OPTARG}"
1101             else
1102                 echo -e "Invalid argument for -O : ' $OPTARG'\n" >&2
1103                 usage && exit 1
1104             fi
1105             ;;
1106         f)
1107             OPENSTACK_SSH_KEY_FILE="${OPTARG}"
1108             ;;
1109         F)
1110             OPENSTACK_USERDATA_FILE="${OPTARG}"
1111             ;;
1112         N)
1113             OPENSTACK_PUBLIC_NET_NAME="${OPTARG}"
1114             ;;
1115         m)
1116             [ "${OPTARG}" == "NG-UI" ] && TO_REBUILD="$TO_REBUILD NG-UI" && continue
1117             [ "${OPTARG}" == "NBI" ] && TO_REBUILD="$TO_REBUILD NBI" && continue
1118             [ "${OPTARG}" == "LCM" ] && TO_REBUILD="$TO_REBUILD LCM" && continue
1119             [ "${OPTARG}" == "RO" ] && TO_REBUILD="$TO_REBUILD RO" && continue
1120             [ "${OPTARG}" == "MON" ] && TO_REBUILD="$TO_REBUILD MON" && continue
1121             [ "${OPTARG}" == "POL" ] && TO_REBUILD="$TO_REBUILD POL" && continue
1122             [ "${OPTARG}" == "PLA" ] && TO_REBUILD="$TO_REBUILD PLA" && continue
1123             [ "${OPTARG}" == "osmclient" ] && TO_REBUILD="$TO_REBUILD osmclient" && continue
1124             [ "${OPTARG}" == "KAFKA" ] && TO_REBUILD="$TO_REBUILD KAFKA" && continue
1125             [ "${OPTARG}" == "MONGO" ] && TO_REBUILD="$TO_REBUILD MONGO" && continue
1126             [ "${OPTARG}" == "PROMETHEUS" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS" && continue
1127             [ "${OPTARG}" == "PROMETHEUS-CADVISOR" ] && TO_REBUILD="$TO_REBUILD PROMETHEUS-CADVISOR" && continue
1128             [ "${OPTARG}" == "KEYSTONE-DB" ] && TO_REBUILD="$TO_REBUILD KEYSTONE-DB" && continue
1129             [ "${OPTARG}" == "GRAFANA" ] && TO_REBUILD="$TO_REBUILD GRAFANA" && continue
1130             [ "${OPTARG}" == "NONE" ] && TO_REBUILD="$TO_REBUILD NONE" && continue
1131             ;;
1132         H)
1133             OSM_VCA_HOST="${OPTARG}"
1134             ;;
1135         S)
1136             OSM_VCA_SECRET="${OPTARG}"
1137             ;;
1138         s)
1139             OSM_NAMESPACE="${OPTARG}" && [[ ! "${OPTARG}" =~ $RE_CHECK ]] && echo "Namespace $OPTARG is invalid. Regex used for validation is $RE_CHECK" && exit 0
1140             ;;
1141         t)
1142             OSM_DOCKER_TAG="${OPTARG}"
1143             REPO_ARGS+=(-t "$OSM_DOCKER_TAG")
1144             ;;
1145         U)
1146             DOCKER_USER="${OPTARG}"
1147             ;;
1148         P)
1149             OSM_VCA_PUBKEY=$(cat ${OPTARG})
1150             ;;
1151         A)
1152             OSM_VCA_APIPROXY="${OPTARG}"
1153             ;;
1154         l)
1155             LXD_CLOUD_FILE="${OPTARG}"
1156             ;;
1157         L)
1158             LXD_CRED_FILE="${OPTARG}"
1159             ;;
1160         K)
1161             CONTROLLER_NAME="${OPTARG}"
1162             ;;
1163         d)
1164             DOCKER_REGISTRY_URL="${OPTARG}"
1165             ;;
1166         p)
1167             DOCKER_PROXY_URL="${OPTARG}"
1168             ;;
1169         T)
1170             MODULE_DOCKER_TAG="${OPTARG}"
1171             ;;
1172         -)
1173             [ "${OPTARG}" == "help" ] && usage && exit 0
1174             [ "${OPTARG}" == "source" ] && INSTALL_FROM_SOURCE="y" && PULL_IMAGES="" && continue
1175             [ "${OPTARG}" == "debug" ] && DEBUG_INSTALL="--debug" && continue
1176             [ "${OPTARG}" == "develop" ] && DEVELOP="y" && continue
1177             [ "${OPTARG}" == "uninstall" ] && UNINSTALL="y" && continue
1178             [ "${OPTARG}" == "update" ] && UPDATE="y" && continue
1179             [ "${OPTARG}" == "reconfigure" ] && RECONFIGURE="y" && continue
1180             [ "${OPTARG}" == "test" ] && TEST_INSTALLER="y" && continue
1181             [ "${OPTARG}" == "lxdinstall" ] && INSTALL_LXD="y" && continue
1182             [ "${OPTARG}" == "nolxd" ] && INSTALL_NOLXD="y" && continue
1183             [ "${OPTARG}" == "nodocker" ] && INSTALL_NODOCKER="y" && continue
1184             [ "${OPTARG}" == "showopts" ] && SHOWOPTS="y" && continue
1185             [ "${OPTARG}" == "nohostports" ] && NO_HOST_PORTS="y" && continue
1186             [ "${OPTARG}" == "nojuju" ] && INSTALL_NOJUJU="--nojuju" && continue
1187             [ "${OPTARG}" == "nodockerbuild" ] && DOCKER_NOBUILD="y" && continue
1188             [ "${OPTARG}" == "nohostclient" ] && INSTALL_NOHOSTCLIENT="y" && continue
1189             [ "${OPTARG}" == "pullimages" ] && continue
1190             [ "${OPTARG}" == "k8s_monitor" ] && INSTALL_K8S_MONITOR="y" && continue
1191             [ "${OPTARG}" == "charmed" ] && CHARMED="y" && OSM_INSTALLATION_TYPE="Charmed" && continue
1192             [ "${OPTARG}" == "bundle" ] && continue
1193             [ "${OPTARG}" == "k8s" ] && continue
1194             [ "${OPTARG}" == "lxd" ] && continue
1195             [ "${OPTARG}" == "lxd-cred" ] && continue
1196             [ "${OPTARG}" == "microstack" ] && continue
1197             [ "${OPTARG}" == "overlay" ] && continue
1198             [ "${OPTARG}" == "only-vca" ] && continue
1199             [ "${OPTARG}" == "small-profile" ] && continue
1200             [ "${OPTARG}" == "vca" ] && continue
1201             [ "${OPTARG}" == "ha" ] && continue
1202             [ "${OPTARG}" == "tag" ] && continue
1203             [ "${OPTARG}" == "registry" ] && continue
1204             [ "${OPTARG}" == "pla" ] && INSTALL_PLA="y" && continue
1205             [ "${OPTARG}" == "ng-sa" ] && INSTALL_NGSA="y" && continue
1206             [ "${OPTARG}" == "volume" ] && OPENSTACK_ATTACH_VOLUME="true" && continue
1207             [ "${OPTARG}" == "nocachelxdimages" ] && continue
1208             [ "${OPTARG}" == "cachelxdimages" ] && INSTALL_CACHELXDIMAGES="--cachelxdimages" && continue
1209             echo -e "Invalid option: '--$OPTARG'\n" >&2
1210             usage && exit 1
1211             ;;
1212         :)
1213             echo "Option -$OPTARG requires an argument" >&2
1214             usage && exit 1
1215             ;;
1216         \?)
1217             echo -e "Invalid option: '-$OPTARG'\n" >&2
1218             usage && exit 1
1219             ;;
1220         h)
1221             usage && exit 0
1222             ;;
1223         y)
1224             ASSUME_YES="y"
1225             ;;
1226         *)
1227             usage && exit 1
1228             ;;
1229     esac
1230 done
1231
1232 source $OSM_DEVOPS/common/all_funcs
1233
1234 [ -z "${DEBUG_INSTALL}" ] || DEBUG Debug is on
1235 [ -n "$SHOWOPTS" ] && dump_vars && exit 0
1236
1237 # Uninstall if "--uninstall"
1238 if [ -n "$UNINSTALL" ]; then
1239     if [ -n "$CHARMED" ]; then
1240         ${OSM_DEVOPS}/installers/charmed_uninstall.sh -R $RELEASE -r $REPOSITORY -u $REPOSITORY_BASE -D $OSM_DEVOPS -t $DOCKER_TAG "$@" || \
1241         FATAL_TRACK charmed_uninstall "charmed_uninstall.sh failed"
1242     else
1243         ${OSM_DEVOPS}/installers/uninstall_osm.sh "$@" || \
1244         FATAL_TRACK community_uninstall "uninstall_osm.sh failed"
1245     fi
1246     echo -e "\nDONE"
1247     exit 0
1248 fi
1249
1250 # Charmed installation
1251 if [ -n "$CHARMED" ]; then
1252     sudo snap install jq || FATAL "Could not install jq (snap package). Make sure that snap works"
1253     export OSM_TRACK_INSTALLATION_ID="$(date +%s)-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 16)"
1254     track start release $RELEASE none none docker_tag $OSM_DOCKER_TAG none none installation_type $OSM_INSTALLATION_TYPE none none
1255     ${OSM_DEVOPS}/installers/charmed_install.sh --tag $OSM_DOCKER_TAG "$@" || \
1256     FATAL_TRACK charmed_install "charmed_install.sh failed"
1257     wget -q -O- https://osm-download.etsi.org/ftp/osm-13.0-thirteen/README2.txt &> /dev/null
1258     track end installation_type $OSM_INSTALLATION_TYPE
1259     echo -e "\nDONE"
1260     exit 0
1261 fi
1262
1263 # Installation to Openstack
1264 if [ -n "$INSTALL_TO_OPENSTACK" ]; then
1265     install_to_openstack $OPENSTACK_OPENRC_FILE_OR_CLOUD $OPENSTACK_PUBLIC_NET_NAME $OPENSTACK_ATTACH_VOLUME
1266     echo -e "\nDONE"
1267     exit 0
1268 fi
1269
1270 # Community_installer
1271
1272 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" != " NONE" ] && echo $TO_REBUILD | grep -q NONE && FATAL "Incompatible option: -m NONE cannot be used with other -m options"
1273 [ -n "$TO_REBUILD" ] && [ "$TO_REBUILD" == " PLA" ] && [ -z "$INSTALL_PLA" ] && FATAL "Incompatible option: -m PLA cannot be used without --pla option"
1274 # if develop, we force master
1275 [ -z "$COMMIT_ID" ] && [ -n "$DEVELOP" ] && COMMIT_ID="master"
1276 OSM_K8S_WORK_DIR="$OSM_DOCKER_WORK_DIR/osm_pods" && OSM_NAMESPACE_VOL="${OSM_HOST_VOL}/${OSM_NAMESPACE}"
1277 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_K8S_MONITOR" ] && install_k8s_monitoring
1278 [ -n "$INSTALL_ONLY" ] && [ -n "$INSTALL_NGSA" ] && install_osm_ngsa_service
1279 [ -n "$INSTALL_ONLY" ] && echo -e "\nDONE" && exit 0
1280
1281 #Installation starts here
1282 wget -q -O- https://osm-download.etsi.org/ftp/osm-13.0-thirteen/README.txt &> /dev/null
1283 export OSM_TRACK_INSTALLATION_ID="$(date +%s)-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 16)"
1284 install_osm
1285 echo -e "\nDONE"
1286 exit 0