deploy

#! /bin/bash

# Configurable parameters
# If the feature needs different parameters values, they can be set in
# the file {feature}/defaults, which is sourced a little later on.  This
# defaults file SHOULD NOT TOUCH ANY OTHER VARIABLE than these, or hell
# may break loose.

TAR_OWNER=root:0
TAR_GROUP=root:0

DEPLOY_SSH=${DEPLOY_SSH:-ssh}
REMACCT=${REMACCT:+${REMACCT}\@}

# End of configurable parameters

here=${DEPLOY_DIR:-$(pwd)}
scriptdir=$(cd $(dirname $(realpath $0)); pwd)
if ! currentbranch=$(git rev-parse --abbrev-ref HEAD); then
    echo >&2 "We ask the the configuration directory be git versioned"
    exit 1
fi

save_args="$*"
upload=true
verbose=false
debug=false
while [ $# -gt 0 ]; do
    case "$1" in
	-n )
	    upload=false
	    ;;
	-v )
	    verbose=true
	    ;;
	-d )
	    debug=true
	    ;;
	* )
	    break
	    ;;
    esac
    shift
done

feature=$1; shift
hosts="$*"

if ! tpage < /dev/null 2> /dev/null; then
    cat >&2 <<EOF
Template Toolkit is required.
On a Debian based distribution, install libtemplate-perl
On a RPM base distribution, install perl-Template-Toolkit
(available through CPAN with the package Template)
EOF
    exit 1
fi

if [ -z "$feature" ]; then
    echo 'No feature name given'
    exit 1
fi

if echo "$feature" | egrep -q '^_|[/[:space:]]'; then
    echo 'Underscore (_), spaces and slashes (/) not permitted in feature names'
    exit 1
fi

if cd $here/$feature; then
    abshere=$(pwd)
    tpagerc=
    if [ -f tpagerc ]; then
	tpagerc=$abshere/tpagerc
    fi
    if [ -f HOSTS -a -f README ]; then
	allcurrenthosts=$(cat HOSTS \
			      | egrep -v '^(#|[[:space:]]*$)' \
			      | sed -e 's/^.*:https://' \
			      | grep -v '^\?' \
			      | sort \
			      | uniq)
	maybecurrenthosts=$(cat HOSTS \
			      | egrep -v '^(#|[[:space:]]*$)' \
			      | sed -e 's/^.*:https://' \
			      | grep '^\?' \
			      | sed -e 's/^\?//' \
			      | sort \
			      | uniq)
	for h in $allcurrenthosts; do
	    hh=${h//./\\.}
	    if expr "$maybecurrenthosts" : "^$hh\$" > /dev/null; then
		echo >&2 "$h exists with and without ? in HOSTS"
		exit 1
	    fi
	done

	if [ -z "$hosts" ]; then
	    hosts=$(echo "$allcurrenthosts"
		    for h in $maybecurrenthosts; do
			if getent hosts $h > /dev/null; then
			    echo $h
			fi
		    done)
	else
	    if ! hosts=$(ok=/bin/true
			 for h in $hosts; do
			     hh=$h
			     hh_re=${hh//./\\.}
			     if ! ( echo $h | grep -q -e "\\." ); then
				 if hh=$((echo "$allcurrenthosts"
					  echo "$maybecurrenthosts") \
					     | grep -e "^$h\\.") \
					&& [ $(echo "$hh" | wc -l) -gt 1 ]; then
				     echo >&2 "'$h' isn't unique enough"
				     ok=/bin/false
				 fi
			     elif ! (echo "$allcurrenthosts"
				     echo "$maybecurrenthosts") \
					 | grep -q -e "^$hh_re\$"; then
				 echo >&2 "'$h' isn't a staging host"
				 ok=/bin/false
			     fi
			     echo $hh
			 done
			 $ok); then
		exit 1
	    fi
	fi

	declare -A fqdnhosts
	fqdnhosts=()
	for h in $(cat HOSTS); do
	    finalhost=${h%%:*}
	    currenthost=${h##*:}
	    currenthost=${currenthost##\?}
	    hh=${currenthost//./\\.}
	    if echo "$hosts" | grep -q -e "^$hh\$"; then
		fqdnhosts[$currenthost]=$(echo ${fqdnhosts[$currenthost]} ${finalhost})
	    fi
	done
	if $debug; then
	    echo "DEBUG[fqdnhosts] collection of deployment hosts"
	    for currenthost in ${!fqdnhosts[*]}; do
		echo "DEBUG[fqdnhosts] $currenthost => " ${fqdnhosts[$currenthost]}
	    done
	fi

	# Phase 0: Checks
	echo >&2 "===== Phase 0: Checks"
	if $upload; then
	    bail_out=/bin/false
	    defremtimeout=2
	    remtimeout=${REMTIMEOUT:-$defremtimeout}
	    for currenthost in ${!fqdnhosts[*]}; do
                if ! $DEPLOY_SSH -o ConnectTimeout=$remtimeout $REMACCT$currenthost 'exit 0'; then
		    echo >&2 "Failed: ssh $REMACCT$currenthost"
		    bail_out=/bin/true
		fi
	    done
	    if $bail_out; then
		if [ -z "${REMACCT}" ]; then
		    echo >&2 "You may want to try setting REMACCT to your username on that host"
		fi
		echo >&2 "If the network connection to $currenthost is slow, you might want"
		echo >&2 "to try setting REMTIMEOUT to a value higher than $remtimeout"
		echo >&2 ""
		echo >&2 "    REMTIMEOUT=10 REMACCT=username $0 $save_args"
		exit 1
	    fi
	fi

	staging=/tmp/deploy.$$

	if [ -f defaults ]; then
	    . ./defaults
	fi

	if ! mkdir $staging; then
	    echo >&2 "Error: couldn't create directory $staging"
	    exit 2
	fi

	tpage_extra=""
	for pp in $abshere/../preamble.tt2 $abshere/preamble.tt2; do
	    if [ -f "$pp" ]; then
		tpage_extra="$tpage_extra --pre_process='$pp'"
	    fi
	done
	for pp in $abshere/postamble.tt2 $abshere/../postamble.tt2; do
	    if [ -f "$pp" ]; then
		tpage_extra="$tpage_extra --post_process='$pp'"
	    fi
	done

	# Phase 1: Prepare files to be transfered
	echo >&2 "===== Phase 1: Preparing files"
	for currenthost in ${!fqdnhosts[*]}; do
	    data=$staging/$currenthost-data
	    control=$staging/$currenthost-control
	    tarball=$control/deploy.$feature.tar.gz
	    rm -f $tarball

	    if ! mkdir $data; then
		echo >&2 "Error: couldn't create directory $data"
		exit 2
	    fi

	    if ! mkdir $control; then
		echo >&2 "Error: couldn't create directory $control"
		exit 2
	    fi

	    tpage_cmd=$(echo tpage \
			     "--define hosts='${fqdnhosts[$currenthost]}'" \
			     "--define staginghost='$currenthost'" \
			     "--define feature='$feature'" \
			     "--define data='$data'" \
			     "--define control='$control'" \
			     "--define verbose='$verbose'" \
			     "--define scriptdir='$scriptdir'")
	    if [ -n "$tpagerc" ]; then
		tpage_cmd="TPAGERC=$tpagerc $tpage_cmd"
	    fi
	    if $debug; then
		echo "DEBUG[tpage_cmd] $tpage_cmd"
	    fi

	    # Phase 1.1: Run the pre-copy script
	    if [ -x pre-copy ]; then
		( cd $data
		  HOSTS="${fqdnhosts[$currenthost]}" FEATURE="$feature" \
		       DATA="$data" CONTROL="$control" SOURCE="$abshere" \
		       VERBOSE="$verbose" \
		       $abshere/pre-copy )
	    fi

	    # Phase 1.2: Copy common files into staging directory
	    cp README $data/README.$feature
	    
	    # Phase 1.3: Copy common source files into staging directory
	    if [ -d src ]; then
		(
                    cd src;
                    git ls-files -z | xargs -0 tar -cf -
                ) | (
                    cd $data; tar -xpf -
                )
	    fi

	    # Phase 1.4: Copy host specific files into staging directory
	    for h in $( for x in $currenthost ${fqdnhosts[$currenthost]}; do
			    echo $x
			done | sort | uniq
			for x in ${fqdnhosts[$currenthost]}; do
			    echo $x@$currenthost
			done | sort | uniq ); do
		if [ -d $h ]; then
		    (
                        cd $h;
                        git ls-files -z | xargs -0 tar -cf -
                    ) | (
			cd $data; tar -xpf -
                    )
		fi
	    done

	    # Phase 1.5: process template source files in staging directory
	    # and replace them with their respective result
	    find $data -name '*.tt2' -type f | \
		while read src; do
		    src=$(dirname "$src")/$(basename "$src")
		    dst=$(dirname "$src")/$(basename "$src" .tt2)
		    if [ "$src" != "$dst" ]; then
			eval "$tpage_cmd $tpage_extra '$src'" > "$dst"
			chmod --reference="$src" "$dst"
			rm "$src"
		    fi
		done

	    # Phase 1.7: Run post-copy
	    if [ -x post-copy ]; then
		( cd $data
		  HOSTS="${fqdnhosts[$currenthost]}" FEATURE="$feature" \
		       DATA="$data" CONTROL="$control" SOURCE="$abshere" \
		       VERBOSE="$verbose" \
		       $abshere/post-copy )
	    fi

	    # Phase 1.8: Create the host specific pre-unpacking,
	    # post-unpacking and post-deployment scripts
	    for script in pre-unpack post-unpack post-deploy; do
		if [ -f $script.tt2 ]; then
		    src=$script.tt2
		    dst=$control/$script.$feature
		    eval "$tpage_cmd $tpage_extra '$src'" > "$dst"
		    chmod a+x $dst
		elif [ -x $script ]; then
		    dst=$control/$script.$feature
		    cp $script $dst
		    chmod a+x $dst
		fi
	    done

	    # Phase 1.10: Create the local tarball and remove staging directory
	    (
		cd $data
		tar --owner=$TAR_OWNER --group=$TAR_GROUP -czf $tarball *
	    )

	    # Phase 1.20: Create the deployment scripts
	    for src in $scriptdir/_host_helpers/deploy*.tt2; do
		dst=$control/$(basename $src .tt2).$feature
		eval "$tpage_cmd $tpage_extra '$src'" > $dst
		chmod a+x $dst
	    done

	    # Phase 1.21: Copy deploy-remove from REMOVE
	    if [ -f REMOVE ]; then
		dst=$control/deploy-remove.$feature.txt
		cp REMOVE $dst
	    fi

	    # Phase 1.99: Cleanup
	    rm -rf $data
	done

	if $upload; then
	    # Phase 2: Copy tarballs to intended hosts
	    echo >&2 "===== Phase 2: Copying files to remote hosts"
	    successhosts=""
	    for currenthost in ${!fqdnhosts[*]}; do
		control=$staging/$currenthost-control

		echo -n "Copying deployment tarball and deployment files to $currenthost..."
		if scp -q -S $DEPLOY_SSH $control/* $REMACCT$currenthost:/tmp/; then
		    echo done
		    successhosts=$(echo $successhosts $currenthost)
		else
		    echo FAIL
		fi
		rm -rf $control
	    done

	    # Phase 3: Final instructions
	    echo >&2 "===== Phase 3: Final instructions"
	    if [ -n "$successhosts" ]; then
		tpage --define hosts="$successhosts" \
		      --define feature="$feature" \
		      --define scriptdir="$scriptdir" \
		      $scriptdir/_host_helpers/help.tt2
	    else
		cat <<EOF
Copying failed on all hosts.  Please fix the problem, or if someone else
was deploying at the same time as you, simply wait a moment
EOF
	    fi
	    rmdir $staging
	else
	    echo >&2 "No upload selected, tarballs and deploy scripts preserved:"
	    for currenthost in ${!fqdnhosts[*]}; do
		control=$staging/$currenthost-control
		echo >&2
		echo >&2 "${control}:"
		ls $control >&2
	    done
	fi
    else
	echo $feature lacking HOSTS and README
	exit 1
    fi
fi