Merge branch 'develop' of https://labs.etsi.org/rep/tfs/controller into fix/ignore-test-reports (963e8e44) · Commits · TFS / controller

.gitignore

+11 −0

Original line number	Diff line number	Diff line
		@@ -131,6 +131,9 @@ venv.bak/
		# VSCode project settings
		.vscode/

		# Visual Studio project settings
		/.vs

		# Rope project settings
		.ropeproject

		@@ -159,3 +162,11 @@ cython_debug/

		# TeraFlowSDN-generated files
		tfs_runtime_env_vars.sh
		tfs_runtime_env_vars*.sh
		tfs_bchain_runtime_env_vars.sh
		delete_local_deployment.sh
		local_docker_deployment.sh
		local_k8s_deployment.sh

		# Other logs
		*/logs/.log.*

.gitlab-ci.yml

+2 −0

Original line number	Diff line number	Diff line
		@@ -41,3 +41,5 @@ include:
		#- local: '/src/l3_attackmitigator/.gitlab-ci.yml'
		#- local: '/src/slice/.gitlab-ci.yml'
		#- local: '/src/interdomain/.gitlab-ci.yml'
		- local: '/src/pathcomp/.gitlab-ci.yml'
		#- local: '/src/dlt/.gitlab-ci.yml'

deploy.sh

+168 −54

Original line number	Diff line number	Diff line
		@@ -36,9 +36,13 @@ export TFS_K8S_NAMESPACE=${TFS_K8S_NAMESPACE:-"tfs"}
		# If not already set, set additional manifest files to be applied after the deployment
		export TFS_EXTRA_MANIFESTS=${TFS_EXTRA_MANIFESTS:-""}

		# If not already set, set the neew Grafana admin password
		# If not already set, set the new Grafana admin password
		export TFS_GRAFANA_PASSWORD=${TFS_GRAFANA_PASSWORD:-"admin123+"}

		# If not already set, disable skip-build flag.
		# If TFS_SKIP_BUILD is "YES", the containers are not rebuilt-retagged-repushed and existing ones are used.
		export TFS_SKIP_BUILD=${TFS_SKIP_BUILD:-""}

		########################################################################################################################
		# Automated steps start here
		########################################################################################################################
		@@ -58,18 +62,6 @@ kubectl delete namespace $TFS_K8S_NAMESPACE
		kubectl create namespace $TFS_K8S_NAMESPACE
		printf "\n"

		if [[ "$TFS_COMPONENTS" == "monitoring" ]]; then
		echo "Creating secrets for InfluxDB..."
		#TODO: make sure to change this when having a production deployment
		kubectl create secret generic influxdb-secrets --namespace=$TFS_K8S_NAMESPACE \
		--from-literal=INFLUXDB_DB="monitoring" --from-literal=INFLUXDB_ADMIN_USER="teraflow" \
		--from-literal=INFLUXDB_ADMIN_PASSWORD="teraflow" --from-literal=INFLUXDB_HTTP_AUTH_ENABLED="True"
		kubectl create secret generic monitoring-secrets --namespace=$TFS_K8S_NAMESPACE \
		--from-literal=INFLUXDB_DATABASE="monitoring" --from-literal=INFLUXDB_USER="teraflow" \
		--from-literal=INFLUXDB_PASSWORD="teraflow" --from-literal=INFLUXDB_HOSTNAME="localhost"
		printf "\n"
		fi

		echo "Deploying components and collecting environment variables..."
		ENV_VARS_SCRIPT=tfs_runtime_env_vars.sh
		echo "# Environment variables for TeraFlowSDN deployment" > $ENV_VARS_SCRIPT
		@@ -78,53 +70,142 @@ echo "export PYTHONPATH=${PYTHONPATH}" >> $ENV_VARS_SCRIPT

		for COMPONENT in $TFS_COMPONENTS; do
		echo "Processing '$COMPONENT' component..."
		IMAGE_NAME="$COMPONENT:$TFS_IMAGE_TAG"
		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$IMAGE_NAME" \| sed 's,//,/,g' \| sed 's,http:/,,g')

		if [ "$TFS_SKIP_BUILD" != "YES" ]; then
		echo " Building Docker image..."
		BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}.log"

		if [ "$COMPONENT" == "automation" ] \|\| [ "$COMPONENT" == "policy" ]; then
		docker build -t "$IMAGE_NAME" -f ./src/"$COMPONENT"/Dockerfile ./src/"$COMPONENT"/ > "$BUILD_LOG"
		docker build -t "$COMPONENT:$TFS_IMAGE_TAG" -f ./src/"$COMPONENT"/Dockerfile ./src/"$COMPONENT"/ > "$BUILD_LOG"
		elif [ "$COMPONENT" == "pathcomp" ]; then
		BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}-frontend.log"
		docker build -t "$COMPONENT-frontend:$TFS_IMAGE_TAG" -f ./src/"$COMPONENT"/frontend/Dockerfile . > "$BUILD_LOG"

		BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}-backend.log"
		docker build -t "$COMPONENT-backend:$TFS_IMAGE_TAG" -f ./src/"$COMPONENT"/backend/Dockerfile . > "$BUILD_LOG"
		# next command is redundant, but helpful to keep cache updated between rebuilds
		IMAGE_NAME="$COMPONENT-backend:$TFS_IMAGE_TAG-builder"
		docker build -t "$IMAGE_NAME" --target builder -f ./src/"$COMPONENT"/backend/Dockerfile . >> "$BUILD_LOG"
		elif [ "$COMPONENT" == "dlt" ]; then
		BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}-connector.log"
		docker build -t "$COMPONENT-connector:$TFS_IMAGE_TAG" -f ./src/"$COMPONENT"/connector/Dockerfile . > "$BUILD_LOG"

		BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}-gateway.log"
		docker build -t "$COMPONENT-gateway:$TFS_IMAGE_TAG" -f ./src/"$COMPONENT"/gateway/Dockerfile . > "$BUILD_LOG"
		else
		docker build -t "$IMAGE_NAME" -f ./src/"$COMPONENT"/Dockerfile . > "$BUILD_LOG"
		docker build -t "$COMPONENT:$TFS_IMAGE_TAG" -f ./src/"$COMPONENT"/Dockerfile . > "$BUILD_LOG"
		fi

		if [ -n "$TFS_REGISTRY_IMAGE" ]; then
		echo " Pushing Docker image to '$TFS_REGISTRY_IMAGE'..."

		if [ "$COMPONENT" == "pathcomp" ]; then
		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT-frontend:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')

		TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}-frontend.log"
		docker tag "$COMPONENT-frontend:$TFS_IMAGE_TAG" "$IMAGE_URL" > "$TAG_LOG"

		PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}-frontend.log"
		docker push "$IMAGE_URL" > "$PUSH_LOG"

		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT-backend:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')

		TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}-backend.log"
		docker tag "$COMPONENT-backend:$TFS_IMAGE_TAG" "$IMAGE_URL" > "$TAG_LOG"

		PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}-backend.log"
		docker push "$IMAGE_URL" > "$PUSH_LOG"
		elif [ "$COMPONENT" == "dlt" ]; then
		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT-connector:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')

		TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}-connector.log"
		docker tag "$COMPONENT-connector:$TFS_IMAGE_TAG" "$IMAGE_URL" > "$TAG_LOG"

		PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}-connector.log"
		docker push "$IMAGE_URL" > "$PUSH_LOG"

		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT-gateway:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')

		TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}-gateway.log"
		docker tag "$COMPONENT-gateway:$TFS_IMAGE_TAG" "$IMAGE_URL" > "$TAG_LOG"

		PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}-gateway.log"
		docker push "$IMAGE_URL" > "$PUSH_LOG"
		else
		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')

		TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}.log"
		docker tag "$IMAGE_NAME" "$IMAGE_URL" > "$TAG_LOG"
		docker tag "$COMPONENT:$TFS_IMAGE_TAG" "$IMAGE_URL" > "$TAG_LOG"

		PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}.log"
		docker push "$IMAGE_URL" > "$PUSH_LOG"
		fi
		fi
		fi

		echo " Adapting '$COMPONENT' manifest file..."
		MANIFEST="$TMP_MANIFESTS_FOLDER/${COMPONENT}service.yaml"
		cp ./manifests/"${COMPONENT}"service.yaml "$MANIFEST"
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}:" "$MANIFEST" \| cut -d ":" -f3)

		if [ -n "$TFS_REGISTRY_IMAGE" ]; then
		# Registry is set
		if [ "$COMPONENT" == "pathcomp" ]; then
		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT-frontend:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-frontend:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-frontend:${VERSION}#image: $IMAGE_URL#g" "$MANIFEST"

		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT-backend:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-backend:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-backend:${VERSION}#image: $IMAGE_URL#g" "$MANIFEST"
		elif [ "$COMPONENT" == "dlt" ]; then
		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT-connector:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-connector:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-connector:${VERSION}#image: $IMAGE_URL#g" "$MANIFEST"

		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT-gateway:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-gateway:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-gateway:${VERSION}#image: $IMAGE_URL#g" "$MANIFEST"
		else
		IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$COMPONENT:$TFS_IMAGE_TAG" \| sed 's,//,/,g' \| sed 's,http:/,,g')
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT:${VERSION}#image: $IMAGE_URL#g" "$MANIFEST"
		fi

		sed -E -i "s#imagePullPolicy: .*#imagePullPolicy: Always#g" "$MANIFEST"
		else
		# Registry is not set
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT:${VERSION}#image: $IMAGE_NAME#g" "$MANIFEST"
		if [ "$COMPONENT" == "pathcomp" ]; then
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-frontend:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-frontend:${VERSION}#image: $COMPONENT-frontend:$TFS_IMAGE_TAG#g" "$MANIFEST"

		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-backend:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-backend:${VERSION}#image: $COMPONENT-backend:$TFS_IMAGE_TAG#g" "$MANIFEST"
		elif [ "$COMPONENT" == "dlt" ]; then
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-connector:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-connector:${VERSION}#image: $COMPONENT-connector:$TFS_IMAGE_TAG#g" "$MANIFEST"

		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-gateway:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-gateway:${VERSION}#image: $COMPONENT-gateway:$TFS_IMAGE_TAG#g" "$MANIFEST"
		else
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT:${VERSION}#image: $COMPONENT:$TFS_IMAGE_TAG#g" "$MANIFEST"
		fi

		sed -E -i "s#imagePullPolicy: .*#imagePullPolicy: Never#g" "$MANIFEST"
		fi

		# TODO: harmonize names of the monitoring component

		echo " Deploying '$COMPONENT' component to Kubernetes..."
		DEPLOY_LOG="$TMP_LOGS_FOLDER/deploy_${COMPONENT}.log"
		kubectl --namespace $TFS_K8S_NAMESPACE apply -f "$MANIFEST" > "$DEPLOY_LOG"
		COMPONENT_OBJNAME=$(echo "${COMPONENT}" \| sed "s/\_/-/")
		kubectl --namespace $TFS_K8S_NAMESPACE scale deployment --replicas=0 ${COMPONENT_OBJNAME}service >> "$DEPLOY_LOG"
		kubectl --namespace $TFS_K8S_NAMESPACE scale deployment --replicas=1 ${COMPONENT_OBJNAME}service >> "$DEPLOY_LOG"
		#kubectl --namespace $TFS_K8S_NAMESPACE scale deployment --replicas=0 ${COMPONENT_OBJNAME}service >> "$DEPLOY_LOG"
		#kubectl --namespace $TFS_K8S_NAMESPACE scale deployment --replicas=1 ${COMPONENT_OBJNAME}service >> "$DEPLOY_LOG"

		echo " Collecting env-vars for '$COMPONENT' component..."

		SERVICE_DATA=$(kubectl get service ${COMPONENT}service --namespace $TFS_K8S_NAMESPACE -o json)
		SERVICE_DATA=$(kubectl get service ${COMPONENT_OBJNAME}service --namespace $TFS_K8S_NAMESPACE -o json)
		if [ -z "${SERVICE_DATA}" ]; then continue; fi

		# Env vars for service's host address
		@@ -153,15 +234,31 @@ done
		echo "Deploying extra manifests..."
		for EXTRA_MANIFEST in $TFS_EXTRA_MANIFESTS; do
		echo "Processing manifest '$EXTRA_MANIFEST'..."
		if [[ "$EXTRA_MANIFEST" == "servicemonitor" ]]; then
		kubectl apply -f $EXTRA_MANIFEST
		else
		kubectl --namespace $TFS_K8S_NAMESPACE apply -f $EXTRA_MANIFEST
		fi
		printf "\n"
		done
		printf "\n"

		# By now, leave these controls here. Some component dependencies are not well handled.

		if [[ "$TFS_COMPONENTS" == "monitoring" ]]; then
		echo "Waiting for 'MonitoringDB' component..."
		# Kubernetes does not implement --for='condition=available' for statefulsets.
		# By now, we assume a single replica of monitoringdb. To be updated in future releases.
		kubectl wait --namespace $TFS_K8S_NAMESPACE \
		--for=jsonpath='{.status.readyReplicas}'=1 --timeout=300s statefulset/monitoringdb
		printf "\n"
		fi

		# By now, leave this control here. Some component dependencies are not well handled
		for COMPONENT in $TFS_COMPONENTS; do
		echo "Waiting for '$COMPONENT' component..."
		COMPONENT_OBJNAME=$(echo "${COMPONENT}" \| sed "s/\_/-/")
		kubectl wait --namespace $TFS_K8S_NAMESPACE \
		--for='condition=available' --timeout=300s deployment/${COMPONENT}service
		--for='condition=available' --timeout=300s deployment/${COMPONENT_OBJNAME}service
		printf "\n"
		done

		@@ -169,12 +266,12 @@ if [[ "$TFS_COMPONENTS" == "webui" ]] && [[ "$TFS_COMPONENTS" == *"monitoring"
		echo "Configuring WebUI DataStores and Dashboards..."
		sleep 3

		INFLUXDB_HOST="monitoringservice"
		INFLUXDB_PORT=$(kubectl --namespace $TFS_K8S_NAMESPACE get service/monitoringservice -o jsonpath='{.spec.ports[?(@.name=="influxdb")].port}')
		INFLUXDB_URL="http://${INFLUXDB_HOST}:${INFLUXDB_PORT}"
		INFLUXDB_USER=$(kubectl --namespace $TFS_K8S_NAMESPACE get secrets influxdb-secrets -o jsonpath='{.data.INFLUXDB_ADMIN_USER}' \| base64 --decode)
		INFLUXDB_PASSWORD=$(kubectl --namespace $TFS_K8S_NAMESPACE get secrets influxdb-secrets -o jsonpath='{.data.INFLUXDB_ADMIN_PASSWORD}' \| base64 --decode)
		INFLUXDB_DATABASE=$(kubectl --namespace $TFS_K8S_NAMESPACE get secrets influxdb-secrets -o jsonpath='{.data.INFLUXDB_DB}' \| base64 --decode)
		# INFLUXDB_HOST="monitoringservice"
		# INFLUXDB_PORT=$(kubectl --namespace $TFS_K8S_NAMESPACE get service/monitoringservice -o jsonpath='{.spec.ports[?(@.name=="influxdb")].port}')
		# INFLUXDB_URL="http://${INFLUXDB_HOST}:${INFLUXDB_PORT}"
		# INFLUXDB_USER=$(kubectl --namespace $TFS_K8S_NAMESPACE get secrets influxdb-secrets -o jsonpath='{.data.INFLUXDB_ADMIN_USER}' \| base64 --decode)
		# INFLUXDB_PASSWORD=$(kubectl --namespace $TFS_K8S_NAMESPACE get secrets influxdb-secrets -o jsonpath='{.data.INFLUXDB_ADMIN_PASSWORD}' \| base64 --decode)
		# INFLUXDB_DATABASE=$(kubectl --namespace $TFS_K8S_NAMESPACE get secrets influxdb-secrets -o jsonpath='{.data.INFLUXDB_DB}' \| base64 --decode)

		# Exposed through the ingress controller "tfs-ingress"
		GRAFANA_HOSTNAME="127.0.0.1"
		@@ -191,6 +288,8 @@ if [[ "$TFS_COMPONENTS" == "webui" ]] && [[ "$TFS_COMPONENTS" == *"monitoring"
		# Updated Grafana API URL
		GRAFANA_URL_UPDATED="http://${GRAFANA_USERNAME}:${TFS_GRAFANA_PASSWORD}@${GRAFANA_HOSTNAME}:${GRAFANA_PORT}${GRAFANA_BASEURL}"

		echo "export GRAFANA_URL_UPDATED=${GRAFANA_URL_UPDATED}" >> $ENV_VARS_SCRIPT

		echo "Connecting to grafana at URL: ${GRAFANA_URL_DEFAULT}..."

		# Configure Grafana Admin Password
		@@ -202,25 +301,40 @@ if [[ "$TFS_COMPONENTS" == "webui" ]] && [[ "$TFS_COMPONENTS" == *"monitoring"
		}' ${GRAFANA_URL_DEFAULT}/api/user/password
		echo

		# Create InfluxDB DataSource
		# Ref: https://grafana.com/docs/grafana/latest/http_api/data_source/
		curl -X POST -H "Content-Type: application/json" -d '{
		"type" : "influxdb",
		"name" : "InfluxDB",
		"url" : "'"$INFLUXDB_URL"'",
		# TODO: replace user, password and database by variables to be saved
		echo "Creating a datasource..."
		curl -X POST -H "Content-Type: application/json" -H "Accept: application/json" -d '{
		"access" : "proxy",
		"type" : "postgres",
		"name" : "monitoringdb",
		"url" : "monitoringservice:8812",
		"database" : "monitoring",
		"user" : "admin",
		"basicAuth": false,
		"user" : "'"$INFLUXDB_USER"'",
		"password" : "'"$INFLUXDB_PASSWORD"'",
		"isDefault": true,
		"database" : "'"$INFLUXDB_DATABASE"'"
		"jsonData" : {
		"sslmode" : "disable",
		"postgresVersion" : 1100,
		"maxOpenConns" : 0,
		"maxIdleConns" : 2,
		"connMaxLifetime" : 14400,
		"tlsAuth" : false,
		"tlsAuthWithCACert" : false,
		"timescaledb" : false,
		"tlsConfigurationMethod": "file-path",
		"tlsSkipVerify" : true
		},
		"secureJsonData": {
		"password": "quest"
		}
		}' ${GRAFANA_URL_UPDATED}/api/datasources
		echo

		# Create Monitoring Dashboard
		# Ref: https://grafana.com/docs/grafana/latest/http_api/dashboard/
		curl -X POST -H "Content-Type: application/json" \
		-d '@src/webui/grafana_dashboard.json' \
		-d '@src/webui/grafana_dashboard_psql.json' \
		${GRAFANA_URL_UPDATED}/api/dashboards/db
		echo

deploy_component.sh

0 → 100755

+186 −0

File added.

Preview size limit exceeded, changes collapsed.

deploy_mock_blockchain.sh

0 → 100755

+121 −0

Original line number	Diff line number	Diff line
		#!/bin/bash
		# Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.


		########################################################################################################################
		# Read deployment settings
		########################################################################################################################

		# Set the URL of your local Docker registry where the images will be uploaded to.
		REGISTRY_IMAGE="http://localhost:32000/tfs/"

		# Set the tag you want to use for your images.
		IMAGE_TAG="dev"

		# Set the name of the Kubernetes namespace to deploy to.
		K8S_NAMESPACE="tfs-bchain"

		COMPONENT="mock_blockchain"

		########################################################################################################################
		# Automated steps start here
		########################################################################################################################

		# Constants
		GITLAB_REPO_URL="registry.gitlab.com/teraflow-h2020/controller"
		TMP_FOLDER="./tmp"

		# Create a tmp folder for files modified during the deployment
		TMP_MANIFESTS_FOLDER="$TMP_FOLDER/manifests"
		mkdir -p $TMP_MANIFESTS_FOLDER
		TMP_LOGS_FOLDER="$TMP_FOLDER/logs"
		mkdir -p $TMP_LOGS_FOLDER

		echo "Deleting and Creating a new namespace..."
		kubectl delete namespace $K8S_NAMESPACE
		kubectl create namespace $K8S_NAMESPACE
		printf "\n"

		echo "Deploying components and collecting environment variables..."
		ENV_VARS_SCRIPT=tfs_bchain_runtime_env_vars.sh
		echo "# Environment variables for TeraFlow Mock-Blockchain deployment" > $ENV_VARS_SCRIPT
		PYTHONPATH=$(pwd)/src

		echo "Processing '$COMPONENT' component..."
		IMAGE_NAME="$COMPONENT:$IMAGE_TAG"
		IMAGE_URL=$(echo "$REGISTRY_IMAGE/$IMAGE_NAME" \| sed 's,//,/,g' \| sed 's,http:/,,g')

		echo " Building Docker image..."
		BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}.log"
		docker build -t "$IMAGE_NAME" -f ./src/dlt/mock_blockchain/Dockerfile . > "$BUILD_LOG"

		if [ -n "$REGISTRY_IMAGE" ]; then
		echo " Pushing Docker image to '$REGISTRY_IMAGE'..."

		TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}.log"
		docker tag "$IMAGE_NAME" "$IMAGE_URL" > "$TAG_LOG"

		PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}.log"
		docker push "$IMAGE_URL" > "$PUSH_LOG"
		fi

		echo " Adapting '$COMPONENT' manifest file..."
		MANIFEST="$TMP_MANIFESTS_FOLDER/${COMPONENT}.yaml"
		cp ./manifests/"${COMPONENT}".yaml "$MANIFEST"

		if [ -n "$REGISTRY_IMAGE" ]; then
		# Registry is set
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT:${VERSION}#image: $IMAGE_URL#g" "$MANIFEST"
		sed -E -i "s#imagePullPolicy: .*#imagePullPolicy: Always#g" "$MANIFEST"
		else
		# Registry is not set
		VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}:" "$MANIFEST" \| cut -d ":" -f3)
		sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT:${VERSION}#image: $IMAGE_NAME#g" "$MANIFEST"
		sed -E -i "s#imagePullPolicy: .*#imagePullPolicy: Never#g" "$MANIFEST"
		fi

		echo " Deploying '$COMPONENT' component to Kubernetes..."
		DEPLOY_LOG="$TMP_LOGS_FOLDER/deploy_${COMPONENT}.log"
		kubectl --namespace $K8S_NAMESPACE apply -f "$MANIFEST" > "$DEPLOY_LOG"
		COMPONENT_OBJNAME=$(echo "${COMPONENT}" \| sed "s/\_/-/")
		kubectl --namespace $K8S_NAMESPACE scale deployment --replicas=0 ${COMPONENT_OBJNAME} >> "$DEPLOY_LOG"
		kubectl --namespace $K8S_NAMESPACE scale deployment --replicas=1 ${COMPONENT_OBJNAME} >> "$DEPLOY_LOG"

		echo " Collecting env-vars for '$COMPONENT' component..."
		SERVICE_DATA=$(kubectl get service ${COMPONENT_OBJNAME} --namespace $K8S_NAMESPACE -o json)

		# Env vars for service's host address
		SERVICE_HOST=$(echo ${SERVICE_DATA} \| jq -r '.spec.clusterIP')
		ENVVAR_HOST=$(echo "${COMPONENT}_SERVICE_HOST" \| tr '[:lower:]' '[:upper:]')
		echo "export ${ENVVAR_HOST}=${SERVICE_HOST}" >> $ENV_VARS_SCRIPT

		# Env vars for service's 'grpc' port
		SERVICE_PORT_GRPC=$(echo ${SERVICE_DATA} \| jq -r '.spec.ports[] \| select(.name=="grpc") \| .port')
		ENVVAR_PORT_GRPC=$(echo "${COMPONENT}_SERVICE_PORT_GRPC" \| tr '[:lower:]' '[:upper:]')
		echo "export ${ENVVAR_PORT_GRPC}=${SERVICE_PORT_GRPC}" >> $ENV_VARS_SCRIPT

		printf "\n"

		echo "Waiting for '$COMPONENT' component..."
		kubectl wait --namespace $K8S_NAMESPACE \
		--for='condition=available' --timeout=300s deployment/${COMPONENT_OBJNAME}
		printf "\n"

		echo "Deployment Resources:"
		kubectl --namespace $K8S_NAMESPACE get all
		printf "\n"

		echo "Done!"