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