#!/bin/bash
#
# lc_cluman - script for generating the Red Hat Cluster Manager
#	      HA software's configuration files
#
################################################################################

# Usage
usage() {
	cat >&2 <<EOF

Usage:  `basename $0` <-n hostnames> [-s service addresses]
		      [-c heartbeat channel] [-o heartbeat options] [-v]
		      <-d target device> [-d target device...]

	-n hostnames            the nodenames of the primary node and its fail-
				overs
                        	Multiple nodenames are separated by colon (:)
                        	delimeter. The first one is the nodename of the 
				primary node, the others are failover nodenames.
	-s service addresses    the IP addresses to failover
				Multiple addresses are separated by colon (:)
				delimeter.
	-c heartbeat channel	the method to send/rcv heartbeats on
				The default method is multicast, and multicast_
				ipaddress is "225.0.0.11".
	-o heartbeat options    a "catchall" for other heartbeat configuration 
				options
				Multiple options are separated by colon (:)
				delimeter.
	-v			verbose mode
	-d target device        the target device name and mount point
                        	The device name and mount point are separated by
				colon (:) delimeter. 

EOF
	exit 1
}

# Get the library of functions
. @scriptlibdir@/lc_common

#****************************** Global variables ******************************#
TMP_DIR=${CLUMGR_TMP_DIR}		# Temporary directory

declare -a NODE_NAMES			# Node names in the failover group
declare -a SRV_IPADDRS			# Service IP addresses

# Lustre target device names, service names and mount points
declare -a TARGET_DEVNAMES TARGET_SRVNAMES TARGET_MNTPNTS
declare -i TARGET_NUM=0			# Number of targets

# Get and check the positional parameters
VERBOSE_OUTPUT=false
while getopts "n:s:c:o:vd:" OPTION; do
	case $OPTION in
        n)
		HOSTNAME_OPT=$OPTARG 
		PRIM_NODENAME=`echo ${HOSTNAME_OPT} | awk -F":" '{print $1}'`
		if [ -z "${PRIM_NODENAME}" ]; then
			echo >&2 $"`basename $0`: Missing primary nodename!"
			usage
		fi
		HOSTNAME_NUM=`echo ${HOSTNAME_OPT} | awk -F":" '{print NF}'`
		if [ ${HOSTNAME_NUM} -lt 2 ]; then
			echo >&2 $"`basename $0`: Missing failover nodenames!"
			usage
		fi
		;;
        s)
		SRVADDR_OPT=$OPTARG 
		;;
        c)
		HBCHANNEL_OPT=$OPTARG
		HBCHANNEL_OPT=`echo "${HBCHANNEL_OPT}" | sed 's/^"//' \
                               | sed 's/"$//'` 
		if [ -n "${HBCHANNEL_OPT}" ] \
   		&& [ "${HBCHANNEL_OPT}" = "${HBCHANNEL_OPT#*broadcast*}" ] \
   		&& [ "${HBCHANNEL_OPT}" = "${HBCHANNEL_OPT#*multicast*}" ]; then
			echo >&2 $"`basename $0`: Invalid Heartbeat channel" \
				  "- ${HBCHANNEL_OPT}!"
			usage
		fi
		;;
        o)
		HBOPT_OPT=$OPTARG 
		HBOPT_OPT=`echo "${HBOPT_OPT}" | sed 's/^"//' | sed 's/"$//'`
		;;
	v) 
		VERBOSE_OUTPUT=true
		;;
        d)
		DEVICE_OPT=$OPTARG 
		TARGET_DEVNAMES[TARGET_NUM]=`echo ${DEVICE_OPT}|awk -F: '{print $1}'`
		TARGET_MNTPNTS[TARGET_NUM]=`echo ${DEVICE_OPT}|awk -F: '{print $2}'`
		if [ -z "${TARGET_DEVNAMES[TARGET_NUM]}" ]; then
			echo >&2 $"`basename $0`: Missing target device name!"
			usage
		fi
		if [ -z "${TARGET_MNTPNTS[TARGET_NUM]}" ]; then
			echo >&2 $"`basename $0`: Missing mount point for target"\
				  "${TARGET_DEVNAMES[TARGET_NUM]}!"
			usage
		fi
		TARGET_NUM=$(( TARGET_NUM + 1 ))
		;;

        ?) 
		usage 
	esac
done

# Check the required parameters
if [ -z "${HOSTNAME_OPT}" ]; then
	echo >&2 $"`basename $0`: Missing -n option!"
	usage
fi

if [ -z "${DEVICE_OPT}" ]; then
	echo >&2 $"`basename $0`: Missing -d option!"
	usage
fi

# get_nodenames
#
# Get all the node names in this failover group
get_nodenames() {
	declare -i idx
	local nodename_str nodename

	nodename_str=`echo ${HOSTNAME_OPT}|awk '{split($HOSTNAME_OPT, a, ":")}\
		      END {for (i in a) print a[i]}'`
	idx=0
	for nodename in ${nodename_str}
        do
		NODE_NAMES[idx]=${nodename}
		idx=$idx+1
        done

	return 0
}

# get_check_srvIPaddrs
#
# Get and check all the service IP addresses in this failover group
get_check_srvIPaddrs() {
	declare -i idx
	declare -i i
	local srvIPaddr_str srvIPaddr

	srvIPaddr_str=`echo ${SRVADDR_OPT}|awk '{split($SRVADDR_OPT, a, ":")}\
		      END {for (i in a) print a[i]}'`
	idx=0
	for srvIPaddr in ${srvIPaddr_str}
        do
		SRV_IPADDRS[idx]=${srvIPaddr}
		idx=$idx+1
        done

	for ((idx = 0; idx < ${#SRV_IPADDRS[@]}; idx++)); do
	  for ((i = 0; i < ${#NODE_NAMES[@]}; i++)); do
	    # Check service IP address
	    verbose_output "Verifying service IP ${SRV_IPADDRS[idx]} and" \
	    	           "real IP of host ${NODE_NAMES[i]} are in the" \
			   "same subnet..."
	    if ! ${SCRIPT_VERIFY_SRVIP} ${SRV_IPADDRS[idx]} ${NODE_NAMES[i]}
	    then
	      return 1
	    fi
	    verbose_output "OK"
	  done
	done

	return 0
}

# cluman_running host_name
# 
# Run remote command to check whether clumanager service is running in @host_name
cluman_running() {
	local host_name=$1
	local ret_str

	ret_str=`${REMOTE} ${host_name} "/sbin/service clumanager status" 2>&1`
	if [ $? -ne 0 ]; then
		if [ "${ret_str}" != "${ret_str#*unrecognized*}" ]; then
			echo >&2 "`basename $0`: cluman_running() error:"\
			"remote command to ${host_name} error: ${ret_str}!"
			return 2
		else
			return 1
		fi
	fi

	return 0
}

# stop_cluman host_name
#
# Run remote command to stop clumanager service running in @host_name
stop_cluman() {
	local host_name=$1
	local ret_str

	ret_str=`${REMOTE} ${host_name} "/sbin/service clumanager stop" 2>&1`
	if [ $? -ne 0 ]; then
		echo >&2 "`basename $0`: stop_cluman() error:"\
		"remote command to ${host_name} error: ${ret_str}!"
		return 1
	fi

	echo "`basename $0`: Clumanager service is stopped on node ${host_name}."
	return 0
}

# check_cluman
#
# Run remote command to check each node's clumanager service
check_cluman() {
	declare -i idx
	local OK

	# Get and check all the service IP addresses
	if [ -n "${SRVADDR_OPT}" ] && ! get_check_srvIPaddrs; then
		return 1
	fi

	for ((idx = 0; idx < ${#NODE_NAMES[@]}; idx++)); do
		# Check clumanager service status
		cluman_running ${NODE_NAMES[idx]}
		rc=$?
		if [ "$rc" -eq "2" ]; then
			return 1
		elif [ "$rc" -eq "1" ]; then
			verbose_output "Clumanager service is stopped on"\
			"node ${NODE_NAMES[idx]}."
		elif [ "$rc" -eq "0" ]; then
			OK=
			echo -n "`basename $0`: Clumanager service is running on"\
			"${NODE_NAMES[idx]}, go ahead to stop the service and"\
			"generate new configurations? [y/n]:"
			read OK
			if [ "${OK}" = "n" ]; then
				echo "`basename $0`: New Clumanager configurations"\
				"are not generated."
				return 2
			fi

			# Stop clumanager service	
			stop_cluman ${NODE_NAMES[idx]}
		fi
	done

	return 0
}

# get_srvname hostname target_devname
#
# Get the lustre target server name from the node @hostname
get_srvname() {
	local host_name=$1
	local target_devname=$2
	local target_srvname=
	local ret_str

	# Execute remote command to get the target server name
	ret_str=`${REMOTE} ${host_name} \
		"${TUNEFS} --print --verbose ${target_devname} | grep Target:" 2>&1`
	if [ $? -ne 0 ]; then
		echo "`basename $0`: get_srvname() error:" \
		     "from host ${host_name} - ${ret_str}"
		return 1
	fi

	if [ "${ret_str}" != "${ret_str#*Target: }" ]; then
		ret_str=${ret_str#*Target: }
		target_srvname=`echo ${ret_str} | awk '{print $1}'`
	fi
	
	if [ -z "${target_srvname}" ]; then
		echo "`basename $0`: get_srvname() error: Cannot get the"\
		     "server name of target ${target_devname} in ${host_name}!"
		return 1
	fi

	echo ${target_srvname}
	return 0
} 

# get_srvnames
#
# Get server names of all the Lustre targets in this failover group
get_srvnames() {
	declare -i i

	# Initialize the TARGET_SRVNAMES array
	unset TARGET_SRVNAMES

	# Get Lustre target service names
	for ((i = 0; i < ${#TARGET_DEVNAMES[@]}; i++)); do
		TARGET_SRVNAMES[i]=$(get_srvname ${PRIM_NODENAME} \
				     ${TARGET_DEVNAMES[i]})
		if [ $? -ne 0 ]; then
			echo >&2 "${TARGET_SRVNAMES[i]}"
			return 1
		fi
	done

	return 0
}

# check_retval retval
#
# Check the return value of redhat-config-cluster-cmd
check_retval() {
	if [ $1 -ne 0 ]; then
		echo >&2 "`basename $0`: Failed to run ${CONFIG_CMD}!"
		return 1
	fi

	return 0
}

# add_services
#
# Add service tags into the cluster.xml file
add_services() {
	declare -i idx
	declare -i i

	# Add service tag
	for ((i = 0; i < ${#TARGET_SRVNAMES[@]}; i++)); do
		${CONFIG_CMD} --add_service --name=${TARGET_SRVNAMES[i]}
		if ! check_retval $?; then
			return 1
		fi

		for ((idx = 0; idx < ${#SRV_IPADDRS[@]}; idx++)); do
			${CONFIG_CMD} --service=${TARGET_SRVNAMES[i]} \
			--add_service_ipaddress --ipaddress=${SRV_IPADDRS[idx]}
			if ! check_retval $?; then
				return 1
			fi
		done

		${CONFIG_CMD} --service=${TARGET_SRVNAMES[i]} \
			      --add_device \
			      --name=${TARGET_DEVNAMES[i]}
		if ! check_retval $?; then
			return 1
		fi

		${CONFIG_CMD} --service=${TARGET_SRVNAMES[i]} \
			      --device=${TARGET_DEVNAMES[i]} \
			      --mount \
			      --mountpoint=${TARGET_MNTPNTS[i]} \
			      --fstype=lustre
		if ! check_retval $?; then
			return 1
		fi
	done

	return 0
}

# gen_cluster_xml
#
# Run redhat-config-cluster-cmd to create the cluster.xml file
gen_cluster_xml() {
	declare -i idx
	declare -i i
	local mcast_IPaddr
	local node_names
	local hbopt

	[ -e "${CLUMAN_DIR}/cluster.xml" ] && \
	/bin/mv ${CLUMAN_DIR}/cluster.xml ${CLUMAN_DIR}/cluster.xml.old

	# Run redhat-config-cluster-cmd to generate cluster.xml
	# Add clumembd tag
   	if [ "${HBCHANNEL_OPT}" != "${HBCHANNEL_OPT#*broadcast*}" ]; then
		${CONFIG_CMD} --clumembd --broadcast=yes
		${CONFIG_CMD} --clumembd --multicast=no
		if ! check_retval $?; then
			return 1
		fi
	elif [ "${HBCHANNEL_OPT}" != "${HBCHANNEL_OPT#*multicast*}" ]; then
		mcast_IPaddr=`echo ${HBCHANNEL_OPT} | awk '{print $2}'`
		if [ -n "${mcast_IPaddr}" ]; then
			${CONFIG_CMD} --clumembd --multicast=yes\
				      --multicast_ipaddress=${mcast_IPaddr}
			if ! check_retval $?; then
				return 1
			fi
		fi
	fi

	# Add cluster tag
	node_names=
	for ((idx = 0; idx < ${#NODE_NAMES[@]}; idx++)); do
		node_names=${node_names}"${NODE_NAMES[idx]} "
	done

	${CONFIG_CMD} --cluster --name="${node_names}failover group"
	if ! check_retval $?; then
		return 1
	fi

	# Add member tag
	for ((idx = 0; idx < ${#NODE_NAMES[@]}; idx++)); do
		${CONFIG_CMD} --add_member --name=${NODE_NAMES[idx]}
		if ! check_retval $?; then
			return 1
		fi
	done

	# Add service tag
	if ! add_services; then
		return 1
	fi

	# Add other tags
	if [ -n "${HBOPT_OPT}" ]; then
		while read -r hbopt
        	do
			${CONFIG_CMD} ${hbopt}
			if ! check_retval $?; then
				return 1
			fi
        	done < <(echo ${HBOPT_OPT}|awk '{split($HBOPT_OPT, a, ":")}\
			 END {for (i in a) print a[i]}')
	fi

	return 0
}

# create_config
#
# Create the cluster.xml file and scp it to the each node's /etc/
create_config() {
	declare -i idx

	/bin/mkdir -p ${TMP_DIR}
	CONFIG_PRIMNODE=${TMP_DIR}$"/cluster.xml."${PRIM_NODENAME}
	CONFIG_LUSTRE=${TMP_DIR}$"/cluster.xml"${FILE_SUFFIX}

	# Get server names of Lustre targets
	if ! get_srvnames; then
		return 1
	fi

	if [ -s ${CONFIG_PRIMNODE} ]; then
		if [ -n "`/bin/grep ${TARGET_SRVNAMES[0]} ${CONFIG_PRIMNODE}`" ]
		then
			verbose_output "${CONFIG_PRIMNODE} already exists."
			return 0
		else
			[ -e "${CLUMAN_DIR}/cluster.xml" ] && \
			/bin/mv ${CLUMAN_DIR}/cluster.xml ${CLUMAN_DIR}/cluster.xml.old

			/bin/cp -f ${CONFIG_PRIMNODE} ${CLUMAN_DIR}/cluster.xml 

			# Add services into the cluster.xml file
			if ! add_services; then
				return 1
			fi
		fi
	else
		# Run redhat-config-cluster-cmd to generate cluster.xml
		verbose_output "Creating cluster.xml file for" \
			       "${PRIM_NODENAME} failover group hosts..."
		if ! gen_cluster_xml; then
			return 1
		fi
		verbose_output "OK"
	fi

	/bin/mv ${CLUMAN_DIR}/cluster.xml ${CONFIG_LUSTRE}
	[ -e "${CLUMAN_DIR}/cluster.xml.old" ] && \
	/bin/mv ${CLUMAN_DIR}/cluster.xml.old ${CLUMAN_DIR}/cluster.xml

	# scp the cluster.xml file to all the nodes
	verbose_output "Remote copying cluster.xml${FILE_SUFFIX} file to" \
		       "${PRIM_NODENAME} failover group hosts..."
	for ((idx = 0; idx < ${#NODE_NAMES[@]}; idx++)); do
		/bin/cp -f ${CONFIG_LUSTRE} ${TMP_DIR}$"/cluster.xml."${NODE_NAMES[idx]}

		scp ${CONFIG_LUSTRE} ${NODE_NAMES[idx]}:${CLUMAN_DIR}/
		if [ $? -ne 0 ]; then
			echo >&2 "`basename $0`: Failed to scp cluster.xml file"\
				 "to node ${NODE_NAMES[idx]}!"
			return 1
		fi
	done
	verbose_output "OK"

	return 0
}

# Main flow
# Get all the node names
if ! get_nodenames; then
	exit 1
fi

# Check clumanager services
verbose_output "Checking clumanager service in the ${PRIM_NODENAME}"\
	       "failover group hosts..."
check_cluman
rc=$?
if [ "$rc" -eq "2" ]; then
	verbose_output "OK"
	exit 0
elif [ "$rc" -eq "1" ]; then
	exit 1
fi
verbose_output "OK"

# Generate configuration files
if ! create_config; then
	exit 1
fi

exit 0