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