check_irods

#!/usr/bin/env bash
#
# NB this should follow the Nagios plugin guidelines. See
# https://nagios-plugins.org/doc/guidelines.html

# TODO run network connection in separate process and kill it after a certain amount of time. (nagios DEFAULT_SOCKET_TIMEOUT)
# TODO switch to using -p (lowercase) for PORT option
# TODO connecting to something other than iRODS should be a CRITICAL
# TODO add support for verbosity=1 See https://nagios-plugins.org/doc/guidelines.html#VERBOSELEVELS


print_usage() {
	/bin/cat <<EOF
Usage:
 $EXEC_NAME [-v|--verbose][(-P|--port) PORT] IRODS-HOST
 $EXEC_NAME (-h|--help)
 $EXEC_NAME (-?|--usage)
 $EXEC_NAME (-V|--version)
EOF
}


print_description() {
	/bin/cat <<EOF
Nagios plugin that checks to see is if an iRODS server is online. It supports
Nagios version 2 or later and iRODS version 4 or later.

Parameters:
 HOST  the FQDN or IP address of the server hosting the service

Options:
 -h, --help       show help and exit
 -P, --port PORT  the TCP port the iRODS server listens to on HOST (default
                  1247)
 -?, --usage      show a usage message and exit
 -v, --verbose    show additional information, a repeat of this flag will show
                  the response from the server
 -V, --version    show version and exit

Output:
 Unless otherwise indicated, it writes the status of the iRODS service on
 IRODS-HOST to stdout in a form interpretable by nagios. When the plugin
 successfully connects to iRODS, it provides the amount of time it took to
 connect as a performance datum in the form "time=<duration>s" where <duration>
 is the amount of time in seconds.

Exit Status:
 0  connected to iRODS
 2  failed to connect to iRODS
 3  an error occurred or connected to something other than iRODS

© 2024 The Arizona Board of Regents on behalf of The University of Arizona. For
license information, see https://cyverse.org/license.
EOF
}


set -o errexit -o nounset -o pipefail

readonly VERSION=9

readonly DEFAULT_EXEC_NAME=check_irods
readonly DEFAULT_PORT=1247

# exit and return statuses
declare -i -r OK=0
#declare -i -r WARNING=1  # Not used yet
declare -i -r CRITICAL=2
declare -r -r UNKNOWN=3

# verbosity
declare -i -r TERSE=0
#declare -i -r VERBOSE=1   # Not used yet

declare EXEC_NAME


main() {
	# If stderr isn't a terminal, redirect it to stdout
	if ! [[ -t 2 ]]; then
		exec 2>&-
		exec 2>&1
	fi

	verify_sys_cmds

	if ! EXEC_NAME="$(/usr/bin/basename "$(/usr/bin/realpath --canonicalize-missing "$0")")"; then
		printf 'cannot determine executable name, using %s\n' "$DEFAULT_EXEC_NAME" >&2 || true
		EXEC_NAME="$DEFAULT_EXEC_NAME"
	fi
	readonly EXEC_NAME

	declare -A argMap=(
		[help]=''
		[host]=''
		[port]="$DEFAULT_PORT"
		[usage]=''
		[verbose]="$TERSE"
		[version]='' )

	if ! map_args argMap "$@"; then
		print_usage >&2 || true
		return $UNKNOWN
	fi

	if [[ -n "${argMap[help]}" ]]; then
		if ! print_help; then
			return $UNKNOWN
		fi
	elif [[ -n "${argMap[usage]}" ]]; then
		if ! print_usage; then
			return $UNKNOWN
		fi
	elif [[ -n "${argMap[version]}" ]]; then
		if ! print_version; then
			return $UNKNOWN
		fi
	else
		if [[ -z "${argMap[host]}" ]]; then
			printf 'iRODS host required\n' >&2 || true
			print_usage >&2 || true
			return $UNKNOWN
		fi

		ping "${argMap[host]}" "${argMap[port]}" "${argMap[verbose]}" 2> /dev/null
		return
	fi

	return $OK
}


# This checks to see if the system commands used by this script are symbolic links.
# Output:
#  For each command that is a symbolic link, it writes a warning message to stderr.
verify_sys_cmds() {
	local cmds=(
		/bin/cat
		/bin/date
		/usr/bin/basename
		/usr/bin/bc
		/usr/bin/getopt
		/usr/bin/od
		/usr/bin/realpath
		/usr/bin/tr
		/usr/bin/xxd )

	local cmd
	for cmd in "${cmds[@]}"; do
		if [[ -L "$cmd" ]]; then
			printf 'Warning: system command %s is a symbolic link.\n' "$cmd" >&2
		fi
	done
}


# It resolves the command line arguments, storing them in an associative array
# using the long option names as the keys.
# Arguments:
#  The first argument is the name of the associative array where the resolved.
#  The remaining arguments hold the raw command line arguments to resolve.
map_args() {
	local mapVar="$1"
	shift

	local opts
	if ! opts="$(format_opts "$@")"; then
		return 1
	fi

	eval set -- "$opts"

	while true; do
		case "$1" in
			-h|--help)
				eval "$mapVar""[help]=help"
				shift
				;;
			-P|--port)
				eval "$mapVar""[port]='$2'"
				shift 2
				;;
			-\?|--usage)
				eval "$mapVar""[usage]=usage"
				shift
				;;
			-v|--verbose)
				eval "$mapVar"'[verbose]=$(( ${'"$mapVar"'[verbose]} + 1 ))'
				shift
				;;
			-V|--version)
				eval "$mapVar""[version]=version"
				shift
				;;
			--)
				shift
				break
				;;
		esac
	done

	if [[ "$#" -ge 1 ]]; then
		eval "$mapVar""[host]='$1'"
	fi
}


# formats the command line options like `getopt`
# Arguments:
#  the raw command line arguments
# Globals:
#  EXEC_NAME  used to indicate the name of the program in error messages
# Output:
#  It writes the command line arguments as generated by `getopt` to stdout.
format_opts() {
	# getopt doesn't support "?" as a short option, so replace all instances of -?
	# with --usage
	local transArgs=()

	local ai
	for (( ai=1; ai<=$#; ai++ )); do
		local arg="${!ai}"

		if [[ "$arg" =~ ^-[^-] ]]; then
			local shopts=''

			local ci
			for (( ci=1; ci<${#arg}; ci++ )); do
				local c="${arg:$ci:1}"

				if [[ "$c" == '?' ]]; then
					if [[ -n "$shopts" ]]; then
						transArgs+=( -"$shopts" )
						shopts=''
					fi

					transArgs+=( --usage )
		  	else
					shopts+="$c"
				fi
			done

			if [[ -n "$shopts" ]]; then
				transArgs+=( -"$shopts" )
			fi
		else
			transArgs+=( "$arg" )
		fi
	done

	/usr/bin/getopt \
		--name "$EXEC_NAME" \
		--longoptions help,port:,service:,usage,verbose,version,zone: \
		--options 'hP:S:VvZ:' \
		-- "${transArgs[@]}"
}


# displays detailed help
# Output:
#  the help text formatted to fit on an 80 character wide terminal
print_help() {
	print_version
	printf '\n'
	print_usage
	printf '\n'
	print_description
}


# displays the program version in the format required of Nagios plugins
# Globals:
#  EXEC_NAME  indicates the program name in the version string
#  VERSION    indicates the version identifier in the version string
print_version() {
	printf '%s v%s\n' "$EXEC_NAME" "$VERSION"
}


# attempt to connect to an iRODS server and time how long it takes to establish
# a connection
# Arguments:
#  host       the IP address or hostname of the server hosting iRODS
#  port       the TCP port the iRODS listens on
# Globals:
#  CRITICAL  return status when failed to connect to iRODS
#  OK        return status when connected to iRODS
#  UNKNOWN   return status when an error occurred or connected to something
#            other than iRODS
# Output:
#  it writes the status to stdout in a form interpretable by nagios. When the
#  plugin successfully connects to iRODS, it provides the amount of time it took
#  to connect as a performance datum in the form "time=<duration>s" where
#  <duration> is the amount of time in seconds.
# Return:
#  OK        connected to iRODS
#  CRITICAL  failed to connect to iRODS
#  UNKNOWN   an error occurred or connected to something other than iRODS
ping() {
	local host="$1"
	local port="$2"

	local startTime
	startTime="$(/bin/date +%s.%N)"

	if ! exec 3<>/dev/tcp/"$host"/"$port"; then
		printf 'CRITICAL: down\n' || true
		return $CRITICAL
	fi

	trap 'exec 3<&- || true; exec 3>&- || true; trap - RETURN' RETURN

	if ! mk_req HEARTBEAT >&3; then
		return $UNKNOWN
	fi

	local respMsg
	respMsg="$(/bin/cat <&3)"

	if [[ "$respMsg" != HEARTBEAT ]]; then
		printf 'CRITICAL: not iRODS\n' || true
		return $UNKNOWN
	fi

	local stopTime
	stopTime="$(/bin/date +%s.%N)"

	local dt
	if [[ -n "$startTime" ]] && [[ -n "$stopTime" ]]; then
		dt="$(printf '%s - %s\n' "$stopTime" "$startTime" | /usr/bin/bc)"
	fi

	local status='OK: up'

	if [[ -n "${dt-}" ]]; then
		printf -v status '%s | time=%.3fs' "$status" "$dt" || true
	fi

	printf '%s\n' "$status" || true

	return $OK
}


# It creates an iRODS protocol request message.
# Arguments:
#  type  the message type
#  msg   optional the message body
# Output:
#  It writes the serialized request to stdout.
mk_req() {
	local msgType="$1"

	local msg=''
	if [[ $# -ge 2 ]]; then
		msg="$2"
	fi

	local header
	if ! header="$(mk_header "$msgType" ${#msg})"; then
		return 1
	fi

	encode_header_len ${#header}
	printf '%s%s' "$header" "$msg"
}


# It creates an iRODS protocol message header.
# Arguments:
#  type    the message type
#  msgLen  the message body length in bytes
# Output:
#  It writes the message header to stdout.
mk_header() {
	local type="$1"
	local msgLen="$2"

	/bin/cat <<EOX
<MsgHeader_PI>
	<type>$type</type>
	<msgLen>$msgLen</msgLen>
	<errorLen>0</errorLen>
	<bsLen>0</bsLen>
</MsgHeader_PI>
EOX
}


# It encodes the length of a serialized iRODS protocol packet header.
# Arguments:
#  the header length to encode
# Output:
#  the length encoded as 32 bit unsigned integer.
encode_header_len() {
	local len="$1"

	printf '0: %.8x' "$len" | /usr/bin/xxd -revert -g 0
}


# It decodes a serialized iRODS protocol packet header length as a decimal
# Input:
#  the serialized length
# Output:
#  the decimal value to stdout.
decode_header_len() {
	local lenHex
	if ! lenHex="$(decode_header_len_hex)"; then
		return 1
	fi

	printf '%d' $(( 16#$lenHex ))
}


# It decodes a serialized iRODS protocol packet header length as a hexadecimal
# Input:
#  the serialized length
# Output:
#  the hexadecimal value to stdout.
decode_header_len_hex() {
	if ! /usr/bin/od --address-radix n --format x1 --read-bytes 4 | /usr/bin/tr --delete ' '; then
		return 1
	fi
}


main "$@"