services

#!/bin/bash
#
#  Command Line Interface to start all services associated with the Tutorial
#  For this tutorial the commands are merely a convenience script to run docker-compose
#

set -eo pipefail

STELLIO="http://stellio:8080/actuator/health"
SCORPIO="http://scorpio:9090/scorpio/"
ORION="http://orion:1026/version"
CORAINE="http://coraine:1026/admin/health"
CONTEXT="http://context/user-context.jsonld"
CORE_CONTEXT="https://uri.etsi.org/ngsi-ld/v1/ngsi-ld-core-context-v1.8.jsonld"
DATA_LOADER="http://tutorial:3000"
IOT_DEVICES="http://iot-sensors:3001"

USAGE="usage: services [create|orion|scorpio|stellio|coraine|ollama|ollama stop|stop] [--secure]"

if (( $# < 1 )); then
	echo "Illegal number of parameters"
	echo "${USAGE}"
	exit 1
fi

# --secure routes the MCP server and chat-bot through APISIX and turns on token
# checks. Any other extra argument (bar `ollama stop`) selects legacy docker-compose.
secure=false
dockerCmd="docker compose"
for arg in "${@:2}"; do
	case "${arg}" in
		--secure) secure=true ;;
		stop) ;;
		*) dockerCmd="docker-compose" ;;
	esac
done

# Keycloak, APISIX and their Postgres database are only worth the startup cost when
# --secure is passed; folded into every command's docker-compose invocation below.
securityFile=""
[ "${secure}" = true ] && securityFile="-f docker-compose/security.yml"

# $1 is the broker; BROKER_ENDPOINT and TEMPORAL_ENDPOINT are what its docker-compose file hands the MCP server.
setSecurity () {
	local broker="${1:-orion}" direct temporal
	case "${broker}" in
		scorpio) direct="http://scorpio:${SCORPIO_PORT}" ;;
		stellio) direct="http://stellio:${STELLIO_PORT}" ;;
		coraine) direct="http://coraine:${CORAINE_PORT}" ;;
		*) broker=orion; direct="http://orion:${ORION_LD_PORT}" ;;
	esac
	if [ "${secure}" = true ]; then
		export AUTH_ENABLED=true
		export MCP_ENDPOINT="http://apisix:${APISIX_PORT}/mcp"
		export BROKER_ENDPOINT="http://apisix:${APISIX_PORT}/${broker}"
		temporal="http://apisix:${APISIX_PORT}/mintaka"
	else
		export AUTH_ENABLED=false
		export MCP_ENDPOINT="http://mcp-server:${MCP_SERVER_PORT}/mcp"
		export BROKER_ENDPOINT="${direct}"
		temporal="http://mintaka:${MINTAKA_PORT}"
	fi
	# Scorpio and Stellio serve the temporal interface themselves.
	case "${broker}" in
		scorpio|stellio) temporal="${BROKER_ENDPOINT}/ngsi-ld/v1" ;;
	esac
	export TEMPORAL_ENDPOINT="${temporal}"
}

displaySecurity () {
	if [ "${secure}" = true ]; then
		echo -e "\033[1;32mSecured\033[0m: the MCP server is reached through APISIX at \033[4mhttp://localhost:${MCP_PROXY_PORT}/mcp\033[0m"
	else
		echo -e "\033[1;33mUnsecured\033[0m: the MCP server is reached directly at \033[4mhttp://localhost:${MCP_SERVER_PORT}/mcp\033[0m"
	fi
}

pause(){
	printf " "
	count="$1"
	[ "$count" -gt 59 ] && printf "Waiting one minute " || printf " Waiting a few seconds ";
	while [ "$count" -gt 0 ]
	do
		printf "."
		sleep 3
		count=$((count - 3))
	done
	echo ""
}

getHeartbeat(){
	response=$(docker run --network fiware_default --rm "quay.io/curl/curl:${CURL_VERSION}" -s -o /dev/null -w "%{http_code}" "$1") || true
}

waitForOrion () {
	echo -e "\n⏳ Waiting for \033[1;34mOrion-LD\033[0m to be available\n"
	
	while ! [ "$(docker inspect --format='{{.State.Health.Status}}' fiware-orion)" == "healthy" ]
	do
		echo -e "\nContext Broker HTTP state: ${response} (waiting for 200)"
		pause 6
		getHeartbeat "${ORION}"
	done
}

waitForScorpio () {
	echo -e "\n⏳ Waiting for \033[1;34mScorpio\033[0m to respond\n"
	getHeartbeat "${SCORPIO}"
	while [ "${response}" -eq 000 ]
	do
		echo -e "Context Broker HTTP state: ${response} (waiting for 500)"
		pause 6
		getHeartbeat "${SCORPIO}"
	done
}

waitForStellio () {
	echo -e "\n⏳ Waiting for \033[1;34mStellio\033[0m to respond\n"
	waitSeconds=30
	while [ "$(docker run --network fiware_default --rm quay.io/curl/curl:${CURL_VERSION} -s -o /dev/null -w %{http_code} 'http://stellio:8080/ngsi-ld/v1/entities/?type=X')" -eq 000 ]
	do 
	  echo -e "Context Broker HTTP state: " $(curl -s -o /dev/null -w %{http_code} 'http://localhost:8080/ngsi-ld/v1/entities/?type=X') " (waiting for 500)"
	  echo -e "Waiting for ${waitSeconds} seconds ..."
	  sleep ${waitSeconds}
	done
	echo -e "\n⏳ Waiting for all \033[1;34mStellio\033[0m services to be available\n"
	while [ "$(docker run --network fiware_default --rm quay.io/curl/curl:${CURL_VERSION} -s -o /dev/null -w %{http_code} 'http://stellio:8080/ngsi-ld/v1/entities/?type=X')" -eq 500 ]
	do 
	  echo -e "Context Broker HTTP state: " $(curl -s -o /dev/null -w %{http_code} 'http://localhost:8080/ngsi-ld/v1/entities/?type=X') " (waiting for 200)"
	  echo -e "Waiting for ${waitSeconds} seconds ..."
	  sleep ${waitSeconds}
	done
}

waitForCoreContext () {
	echo -e "\n⏳ Checking availability of \033[1m core @context\033[0m from ETSI\n"
	response=$(docker run --rm "quay.io/curl/curl:${CURL_VERSION}" -s -o /dev/null -w "%{http_code}" "$CORE_CONTEXT") || true
	while [ "${response}" -eq 000 ]
	do
		echo -e "\n@context HTTP state: ${response} (waiting for 200)"
		pause 3
		response=$(docker run --rm "quay.io/curl/curl:${CURL_VERSION}" -s -o /dev/null -w "%{http_code}" "$CORE_CONTEXT") || true
	done
}

waitForCoraine () {
	echo -e "\n⏳ Waiting for \033[1;34mCoraine\033[0m to respond\n"
	getHeartbeat "${CORAINE}"
	while [ "${response}" -eq 000 ]
	do
		echo -e "Context Broker HTTP state: ${response} (waiting for 200)"
		pause 6
		getHeartbeat "${CORAINE}"
	done
}

waitForUserContext () {
	echo -e "\n⏳ Waiting for user \033[1m@context\033[0m to be available\n"
	getHeartbeat "${CONTEXT}"
	while [ "${response}" -eq 000 ]
	do
		echo -e "\n@context HTTP state: ${response} (waiting for 200)"
		pause 3
		getHeartbeat "${CONTEXT}"
	done
}

waitForMongo () {
	echo -e "\n⏳ Waiting for \033[1mMongoDB\033[0m to be available\n"
	while ! [ "$(docker inspect --format='{{.State.Health.Status}}' db-mongo)" == "healthy" ]
	do 
		sleep 1
	done
}

waitForIoTAgent () {
	echo -e "\n⏳ Waiting for \033[1;36mIoT-Agent\033[0m to be available\n"
	while [ "$(docker run --network fiware_default --rm quay.io/curl/curl:${CURL_VERSION} -s -o /dev/null -w %{http_code} 'http://iot-agent:4041/version')" -eq 000 ]
 	do 
	  echo -e "IoT Agent HTTP state: " $(curl -s -o /dev/null -w %{http_code} 'http://localhost:4041/version') " (waiting for 200)"
	  sleep 6
	done
}

waitForKeycloak () {
	echo -e "\n⏳ Waiting for \033[1;34mKeycloak\033[0m to be available\n"
	while ! [ "$(docker inspect --format='{{.State.Health.Status}}' fiware-keycloak 2>/dev/null)" == "healthy" ]
	do
		echo -e "Keycloak health: $(docker inspect --format='{{.State.Health.Status}}' fiware-keycloak 2>/dev/null) (waiting for healthy)"
		sleep 5
	done
	echo -e " \033[1;32mdone\033[0m"
}

waitForApisix () {
	echo -e "\n⏳ Waiting for \033[1mAPISIX\033[0m to be available\n"
	while ! [ "$(docker inspect --format='{{.State.Health.Status}}' fiware-apisix 2>/dev/null)" == "healthy" ]
	do
		echo -e "APISIX health: $(docker inspect --format='{{.State.Health.Status}}' fiware-apisix 2>/dev/null) (waiting for healthy)"
		sleep 5
	done
	echo -e " \033[1;32mdone\033[0m"
}

loadUsers () {
	docker run --rm \
		--network fiware_default \
		-v "$(pwd)/import_users:/import_users" \
		-e KEYCLOAK_HOST=keycloak \
		-e KEYCLOAK_PORT=8080 \
		--entrypoint /bin/sh \
		python:3-alpine -c "apk add --no-cache curl && /import_users"
}

loadData () {
	waitForUserContext
	export CONTEXT_BROKER="$1" 
	docker run --rm -v $(pwd)/import-data:/import-data \
	    -v $(pwd)/data/:/home/curl_user/data \
		--network fiware_default \
		-e CONTEXT_BROKER=${CONTEXT_BROKER} \
		-e DATA_LOADER=${DATA_LOADER} \
		-e IOT_DEVICES=${IOT_DEVICES} \
		-e TUTORIAL_DATA_MODELS_CONTEXT="http://context/user-context.jsonld" \
		-e PIG_COUNT=${PIG_COUNT:-4} \
		-e COW_COUNT=${COW_COUNT:-4} \
		--entrypoint /bin/ash quay.io/curl/curl:${CURL_VERSION} /import-data
	waitForIoTAgent
	docker run --rm -v $(pwd)/provision-devices:/provision-devices \
		--network fiware_default \
		-e CONTEXT_BROKER=${CONTEXT_BROKER} \
		-e TUTORIAL_DATA_MODELS_CONTEXT="http://context/user-context.jsonld" \
		--entrypoint /bin/ash quay.io/curl/curl:${CURL_VERSION} /provision-devices
	docker run --rm -v $(pwd)/link-devices:/link-devices \
		--network fiware_default \
		--entrypoint /bin/ash quay.io/curl/curl:${CURL_VERSION} /link-devices
	echo ""
}

stoppingContainers () {
	CONTAINERS=$(docker ps --filter "label=org.fiware=tutorial" -aq)
	if [[ -n "$CONTAINERS" ]]; then 
		echo "Stopping containers"
		docker rm -f $CONTAINERS || true
	fi
	VOLUMES=$(docker volume ls -qf dangling=true) 
	if [[ -n "$VOLUMES" ]]; then 
		echo "Removing old volumes"
		docker volume rm $VOLUMES || true
	fi
	NETWORKS=$(docker network ls  --filter "label=org.fiware=tutorial" -q) 
	if [[ -n "$NETWORKS" ]]; then 
		echo "Removing tutorial networks"
		docker network rm $NETWORKS || true
	fi
}

displayServices () {
	echo ""
	docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" --filter name="$1"

	echo ""
}



addIoTDatabaseIndex () {
	printf "Adding appropriate \033[1mMongoDB\033[0m indexes for \033[1;36mIoT-Agent\033[0m  ..."
	docker exec db-mongo mongosh --eval '
	conn = new Mongo();
	db = conn.getDB("iotagentjson");
	db.getCollectionNames().forEach(c=>db[c].drop());
	db.createCollection("devices");
	db.devices.createIndex({"_id.service": 1, "_id.id": 1, "_id.type": 1});
	db.devices.createIndex({"_id.type": 1});
	db.devices.createIndex({"_id.id": 1});
	db.createCollection("groups");
	db.groups.createIndex({"_id.resource": 1, "_id.apikey": 1, "_id.service": 1});
	db.groups.createIndex({"_id.type": 1});' > /dev/null
	echo -e " \033[1;32mdone\033[0m"
}

command="$1"
case "${command}" in
	"help")
        echo "${USAGE}"
        ;;
	 "orion")
		set -a; source .env; set +a
		setSecurity orion
		stoppingContainers
		waitForCoreContext
		echo -e "Starting containers:  \033[1;34mOrion\033[0m, \033[1;34mMintaka\033[0m, \033[1;36mIoT-Agent\033[0m, \033[1mTutorial\033[0m, a linked data \033[1mContext\033[0m and \033[1mMongoDB\033[0m and \033[1mTimescale\033[0m databases."
		echo -e "- \033[1;34mOrion\033[0m is the context broker - writes history to Timescale"
		echo -e "- \033[1;34mMintaka\033[0m offers the NGSI-LD temporal interface - reads from Timescale"
		echo -e "- \033[1mTutorial\033[0m displays a web app to manipulate the context directly"
		echo -e "- \033[1mIoT Devices\033[0m acts as a series of dummy IoT Sensors over HTTP"
		echo -e "- \033[1mMCP Server\033[0m exposes the context broker to LLM agents"
		echo -e "- \033[1mChat-bot\033[0m serves a web UI and LLM agent loop over the MCP Server"
		if [ "${secure}" = true ]; then
			echo -e "- \033[1;34mKeycloak\033[0m is the Identity and Access Management server"
			echo -e "- \033[1mAPISix\033[0m is an API Gateway securing the \033[1mMCP Server\033[0m and the context broker"
		fi
		echo -e "- Data models \033[1m@context\033[0m (Smart Farm) is supplied externally"
		echo ""
		${dockerCmd} -f docker-compose/mintaka.yml -p fiware up -d --renew-anon-volumes
		pause 10
		${dockerCmd} -f docker-compose/common.yml ${securityFile} -f docker-compose/orion-ld.yml -p fiware up -d --renew-anon-volumes
		displayServices "orion|fiware"
		if [ "${secure}" = true ]; then
			waitForKeycloak
			loadUsers
			waitForApisix
		fi
		waitForMongo
		waitForOrion
		loadData orion:1026
		echo -e "\033[1;34m${command}\033[0m is now running and exposed on localhost:${EXPOSED_PORT}"
		echo -e "Now open \033[4mhttp://localhost:3000/device/monitor\033[0m"
		echo -e "Chat with the farm at \033[4mhttp://localhost:${CHAT_BOT_PORT}\033[0m"
		displaySecurity
		;;

	"scorpio")
		set -a; source .env; set +a
		setSecurity scorpio
		stoppingContainers
		waitForCoreContext
		echo -e "Starting containers:  \033[1;34mScorpio\033[0m, and a \033[1mPostgres\033[0m database, \033[1;34mQuantumLeap\033[0m, \033[1;36mIoT-Agent\033[0m, \033[1mTutorial\033[0m, a linked data \033[1mContext\033[0m and \033[1mMongoDB\033[0m database."
		echo -e "- \033[1;Scorpio\033[0m is the context broker"
		echo -e "- \033[1mTutorial\033[0m displays a web app to manipulate the context directly"
		echo -e "- \033[1mIoT Devices\033[0m acts as a series of dummy IoT Sensors over HTTP"
		echo -e "- \033[1mMCP Server\033[0m exposes the context broker to LLM agents"
		echo -e "- \033[1mChat-bot\033[0m serves a web UI and LLM agent loop over the MCP Server"
		if [ "${secure}" = true ]; then
			echo -e "- \033[1;34mKeycloak\033[0m is the Identity and Access Management server"
			echo -e "- \033[1mAPISix\033[0m is an API Gateway securing the \033[1mMCP Server\033[0m and the context broker"
		fi
		echo -e "- Data models \033[1m@context\033[0m (Smart Farm) is supplied externally"
		echo ""
		${dockerCmd} -f docker-compose/common.yml ${securityFile} -f docker-compose/scorpio.yml -p fiware up -d --renew-anon-volumes
		displayServices "scorpio|fiware"
		if [ "${secure}" = true ]; then
			waitForKeycloak
			loadUsers
			waitForApisix
		fi
		waitForMongo
		addIoTDatabaseIndex
		waitForScorpio
		loadData scorpio:9090
		echo -e "\033[1;34m${command}\033[0m is now running and exposed on localhost:${EXPOSED_PORT}"
		echo -e "Now open \033[4mhttp://localhost:3000/device/monitor\033[0m"
		echo -e "Chat with the farm at \033[4mhttp://localhost:${CHAT_BOT_PORT}\033[0m"
		displaySecurity
		;;
	"stellio")
		set -a; source .env; set +a
		setSecurity stellio
		stoppingContainers
		waitForCoreContext
		echo -e "Starting containers:  \033[1;34mStellio\033[0m, \033[1mKafka\033[0m, \033[1mZookeeper\033[0m and a \033[1mPostgres\033[0m database, \033[1;34mQuantumLeap\033[0m, \033[1;36mIoT-Agent\033[0m, \033[1mTutorial\033[0m, a linked data \033[1mContext\033[0m and \033[1mMongoDB\033[0m database."
		echo -e "- \033[1;Stellio\033[0m is the context broker"
		echo -e "- \033[1mTutorial\033[0m displays a web app to manipulate the context directly"
		echo -e "- \033[1mIoT Devices\033[0m acts as a series of dummy IoT Sensors over HTTP"
		echo -e "- \033[1mMCP Server\033[0m exposes the context broker to LLM agents"
		echo -e "- \033[1mChat-bot\033[0m serves a web UI and LLM agent loop over the MCP Server"
		if [ "${secure}" = true ]; then
			echo -e "- \033[1;34mKeycloak\033[0m is the Identity and Access Management server"
			echo -e "- \033[1mAPISix\033[0m is an API Gateway securing the \033[1mMCP Server\033[0m and the context broker"
		fi
		echo -e "- Data models \033[1m@context\033[0m (Smart Farm) is supplied externally"
		echo ""
		${dockerCmd} -f docker-compose/common.yml ${securityFile} -f docker-compose/stellio.yml -p fiware up -d --renew-anon-volumes
		displayServices "stellio|fiware"
		if [ "${secure}" = true ]; then
			waitForKeycloak
			loadUsers
			waitForApisix
		fi
		waitForMongo
		addIoTDatabaseIndex
		waitForStellio
		loadData stellio:8080
		echo -e "\033[1;34m${command}\033[0m is now running and exposed on localhost:${EXPOSED_PORT}"
		echo -e "Now open \033[4mhttp://localhost:3000/device/monitor\033[0m"
		echo -e "Chat with the farm at \033[4mhttp://localhost:${CHAT_BOT_PORT}\033[0m"
		displaySecurity
		;;
	"ollama")
		set -a; source .env; set +a
		setSecurity
		if [ "$2" == "stop" ]; then
			echo -e "Stopping \033[1;34mOllama\033[0m"
			${dockerCmd} -f docker-compose/common.yml -f docker-compose/ollama.yml -p fiware rm -sf ollama ollama-init
			if [ -n "$(docker ps -q -f name=fiware-chat-bot)" ]; then
				echo -e "Reverting \033[1mChat-bot\033[0m to the host Ollama URL"
				${dockerCmd} -f docker-compose/common.yml -p fiware up -d --no-deps --force-recreate chat-bot
			fi
		else
			echo -e "Starting \033[1;34mOllama\033[0m in the tutorial network and pulling \033[1m${OLLAMA_MODEL}\033[0m"
			${dockerCmd} -f docker-compose/common.yml -f docker-compose/ollama.yml -p fiware up -d ollama ollama-init
			if [ -n "$(docker ps -q -f name=fiware-chat-bot)" ]; then
				echo -e "Re-pointing \033[1mChat-bot\033[0m at \033[4mhttp://ollama:11434/v1\033[0m"
				${dockerCmd} -f docker-compose/common.yml -f docker-compose/ollama.yml -p fiware up -d --no-deps --force-recreate chat-bot
			fi
			displayServices "ollama|chat-bot"
			echo -e "\033[1;34mOllama\033[0m is running on localhost:11434 - the model pull runs in the background"
			echo -e "Follow it with \033[1mdocker logs -f fiware-ollama-init\033[0m"
			echo -e "Set \033[1mCHAT_BOT_PROVIDER=ollama\033[0m or pick \033[1mollama\033[0m in the chat-bot UI"
		fi
		;;
	 "coraine")
		# TEMPLATE - adjust as needed. Coraine has a native temporal interface: the
		# --troe timescale plugin (see coraine.yml) writes history to the bundled
		# db-timescale, so Mintaka (Orion-LD specific) is not started here.
		set -a; source .env; set +a
		setSecurity coraine
		stoppingContainers
		waitForCoreContext
		echo -e "Starting containers:  \033[1;34mCoraine\033[0m, \033[1;36mIoT-Agent\033[0m, \033[1mTutorial\033[0m, a linked data \033[1mContext\033[0m and \033[1mMongoDB\033[0m and \033[1mTimescale\033[0m databases."
		echo -e "- \033[1;34mCoraine\033[0m is the context broker - writes history to Timescale via --troe timescale"
		echo -e "- \033[1mTutorial\033[0m displays a web app to manipulate the context directly"
		echo -e "- \033[1mIoT Devices\033[0m acts as a series of dummy IoT Sensors over HTTP"
		echo -e "- \033[1mMCP Server\033[0m exposes the context broker to LLM agents"
		echo -e "- \033[1mChat-bot\033[0m serves a web UI and LLM agent loop over the MCP Server"
		if [ "${secure}" = true ]; then
			echo -e "- \033[1;34mKeycloak\033[0m is the Identity and Access Management server"
			echo -e "- \033[1mAPISix\033[0m is an API Gateway securing the \033[1mMCP Server\033[0m and the context broker"
		fi
		echo -e "- Data models \033[1m@context\033[0m (Smart Farm) is supplied externally"
		echo ""
		${dockerCmd} -f docker-compose/common.yml ${securityFile} -f docker-compose/coraine.yml -p fiware up -d --renew-anon-volumes
		displayServices "coraine|fiware"
		if [ "${secure}" = true ]; then
			waitForKeycloak
			loadUsers
			waitForApisix
		fi
		waitForMongo
		waitForCoraine
		loadData coraine:1026
		echo -e "\033[1;34m${command}\033[0m is now running and exposed on localhost:${EXPOSED_PORT}"
		echo -e "Now open \033[4mhttp://localhost:3000/device/monitor\033[0m"
		echo -e "Chat with the farm at \033[4mhttp://localhost:${CHAT_BOT_PORT}\033[0m"
		displaySecurity
		;;
	"stop")
		set -a; source .env; set +a
		setSecurity
		stoppingContainers
		;;
	"start")
		set -a; source .env; set +a
		setSecurity
		./services ${CONTEXT_BROKER:=orion} "${@:2}"
 		;;
 	"create")
		set -a; source .env; set +a
		setSecurity
		echo "Pulling Docker images"
		docker pull -q quay.io/curl/curl:${CURL_VERSION}
		docker pull -q quay.io/fiware/tutorials.mcp-server
		${dockerCmd} -f docker-compose/common.yml -f docker-compose/security.yml -f docker-compose/scorpio.yml -f docker-compose/orion-ld.yml -f docker-compose/stellio.yml -f docker-compose/mintaka.yml -f docker-compose/coraine.yml pull --ignore-buildable
		echo "Building the Chat-bot image"
		${dockerCmd} -f docker-compose/common.yml -p fiware build chat-bot
		;;
	*)
		echo "Command not Found."
		echo "${USAGE}"
		exit 127;
		;;
esac