projects / osm / devops.git / blob
? search:


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