#!/bin/bash

CONTAINERS="dev-mysql dev-controller dev-ssh dev-rails dev-django dev-nginx dev-smtpsink dev-registry"


die()
{
	echo "error: $*" >&2
	exit 1
}

# generate the .env file for docker-compose
#
# DOCKERUSER is set to the uid:gid of the current user
#
# If the file already exists, it will never be replaced. The function just
# prints a warning if it differs from the would-be generated file.
generate_env_file()
{
	cat >".env.tmp" <<EOF
DOCKERUSER=`id -u`:`id -g`
EOF
	if [ ! -e .env ] ; then
		mv .env.tmp .env
	else
		if cmp --quiet .env .env.tmp ; then
			rm .env.tmp
		else
			echo "warning: config file '.env' already exists and is different from the generate config. Remove it if you want it to be overwritten."
			diff -u .env .env.tmp || true
		fi
	fi
}

# install the tokens certificate into the registry external volume
install_secrets()
{
	src=data/django/ro/certs/tokens.crt
	dst=data/registry/ro/certs/tokens.crt

	if [ -f "$src" ] && [ -d "`dirname "$dst"`" ] && ! cmp -s "$src" "$dst" ; then
		echo "Install tokens certificate as $dst/tokens.crt"
		cp "$src" "$dst"
		docker-compose restart dev-registry
	fi
}

# generate the factories
#
# this function is run after the rails container is initialised because the
# list of factories is read from the database
build_factories()
{
	# build the factories
	for name in `echo 'select concat(name, ":", version) as img from docker_os order by img;' | docker exec -i dev-mysql mysql -uroot allgo | grep -v '^img$'`
	do
		tag="localhost:8002/allgo/dev/factory/$name"
		if docker inspect --type image -- "$name" >/dev/null 2>/dev/null
		then
			echo "$name: already pulled"
			(set -x
			docker tag  -- "$name" "$tag"
			docker push -- "$tag"
			docker rmi  -- "$name" || true
			)
		else
			echo "$name:"
			(set -x
			docker pull -- "$name"
			docker tag  -- "$name" "$tag"
			docker push -- "$tag"
			docker rmi  -- "$name"
			)
		fi
	done
}

# remove container and its data
purge_container()
{
	local name="$1"

	(set -x ; docker-compose rm -f "$name")

	# ensure $name is well formatted (to avoid disasters with rm -rf)
	[[ "$name" =~ ^dev-[a-z][a-z0-9-]*$ ]] || die "bad container name: $name"
	local data_dir="data/${name/dev-/}"

	if [ -e "$data_dir" ] ; then
		echo "warning: data dir '$data_dir' already exists"
		echo -n "remove it [y/N]? "
		read confirm
		[ "$confirm" = "y" ] || die "aborted"

		(set -x ; rm -rf -- "$data_dir")
	fi
}

# init a container
init_container()
{
	local name="$1"
	local data_dir="data/${name/dev-/}"

	(set -x

	# create the directory before running the container
	# so that it is owned by the current user (not by root)
	mkdir -p -- "$data_dir"


	# run the /dk/container_init script if present
	#
	# FIXME: the "sleep 1" is because of a race condition in
	# docker-compose (if the command finishes too quickly, then it
	# is run twice)
	docker-compose run --rm "$name" sh -e -c \
	  'if [ -f /dk/container_init ] ; then sleep 1; /dk/container_init ; fi'

	# start the container
	docker-compose up -d "$name"
	)
}


##################################################################


if [ ! -f docker-compose.yml ] || [ ! -f bootstrap ] ; then
	die "the 'bootstrap' script must be run from the root of the allgo repository"
fi

if [ "$1" == "-h" ] ; then
	cat <<EOF
usage: $0 [-n|--nobuild] [CONTAINER ...]

The bootstrap script initialises the environment and the selected containers
(or by default all the containers).

If a container is already initialised, then the script asks for confirmation
before purging its data (to bootstrap it again).

Options:
  -n,--nobuild	do not rebuild the images

EOF
fi

if [ "$1" == "-n" ] || [ "$1" = "--nobuild" ] ; then
	NOBUILD=1
	shift
else
	NOBUILD=
fi

# selection of the containers to be generated
if [ -n "$*" ] ; then
	TODO="$*"
else
	docker-compose down
	TODO="$CONTAINERS"
fi

set -e

# purge containers (container + external volumes) that will be bootstraped
for name in $TODO
do
	purge_container "$name"
done

generate_env_file

if [ -z "$NOBUILD" ] ; then
	# build base image (if not present)
	(set -x ; make base-debian)

	# build the requested images images
	docker-compose build $TODO
fi

# initialise the containers
for name in $TODO
do
	init_container "$name"
done

# build the factories (if the rail container was initialised)
if [ -z "$NOBUILD" ] && echo "$TODO" | grep -q dev-rails ; then
	build_factories
fi

install_secrets

# display running containers
docker-compose ps