echo 'CTDB_BASE unset in CTDB functions file'
exit 1
fi
+export CTDB_BASE
+# CTDB_VARDIR is used elsewhere
+# shellcheck disable=SC2034
CTDB_VARDIR="/usr/local/var/lib/ctdb"
ctdb_rundir="/usr/local/var/run/ctdb"
+CTDB="${CTDB:-/usr/local/bin/ctdb}"
+
# Only (and always) override these variables in test code
if [ -z "$CTDB_SCRIPT_VARDIR" ] ; then
else
_opts="${CTDB_DBDIR#tmpfs:}"
fi
- # This is an internal variable, only used by ctdbd_wrapper.
- # It is OK to repeat mount options - last value wins
+ # It is OK to repeat mount options - last value wins.
+ # CTDB_DBDIR_TMPFS_OPTIONS is used by ctdbd_wrapper
+ # shellcheck disable=SC2034
CTDB_DBDIR_TMPFS_OPTIONS="${_opts_defaults}${_opts:+,}${_opts}"
CTDB_DBDIR="${ctdb_rundir}/CTDB_DBDIR"
;;
*)
+ # shellcheck disable=SC2034
CTDB_DBDIR_TMPFS_OPTIONS=""
esac
}
return
fi
- if [ -f $CTDB_SYS_ETCDIR/sysconfig/$1 ]; then
- . $CTDB_SYS_ETCDIR/sysconfig/$1
- elif [ -f $CTDB_SYS_ETCDIR/default/$1 ]; then
- . $CTDB_SYS_ETCDIR/default/$1
- elif [ -f $CTDB_BASE/sysconfig/$1 ]; then
- . $CTDB_BASE/sysconfig/$1
+ if [ -f "${CTDB_SYS_ETCDIR}/sysconfig/$1" ]; then
+ . "${CTDB_SYS_ETCDIR}/sysconfig/$1"
+ elif [ -f "${CTDB_SYS_ETCDIR}/default/$1" ]; then
+ . "${CTDB_SYS_ETCDIR}/default/$1"
+ elif [ -f "${CTDB_BASE}/sysconfig/$1" ]; then
+ . "${CTDB_BASE}/sysconfig/$1"
fi
if [ "$1" = "ctdb" ] ; then
##############################################################
-# CTDB_SCRIPT_DEBUGLEVEL can be overwritten by setting it in a
-# configuration file.
-debug ()
-{
- if [ ${CTDB_SCRIPT_DEBUGLEVEL:-2} -ge 4 ] ; then
- # If there are arguments then echo them. Otherwise expect to
- # use stdin, which allows us to pass lots of debug using a
- # here document.
- if [ -n "$1" ] ; then
- echo "DEBUG: $*"
- else
- sed -e 's@^@DEBUG: @'
- fi
- else
- if [ -z "$1" ] ; then
- cat >/dev/null
- fi
- fi
-}
-
die ()
{
_msg="$1"
_rc="${2:-1}"
echo "$_msg" >&2
- exit $_rc
+ exit "$_rc"
}
# Log given message or stdin to either syslog or a CTDB log file
*)
# Handle all syslog:* variants here too. There's no tool to do
# the lossy things, so just use logger.
- logger -t "ctdbd: ${_tag}" $*
+ logger -t "ctdbd: ${_tag}" "$*"
;;
esac
}
$_nice /usr/sbin/service "$_service_name" "$_op"
elif [ -x /bin/systemctl ]; then
$_nice /bin/systemctl "$_op" "$_service_name"
- elif [ -x $CTDB_SYS_ETCDIR/init.d/$_service_name ]; then
- $_nice $CTDB_SYS_ETCDIR/init.d/$_service_name "$_op"
- elif [ -x $CTDB_SYS_ETCDIR/rc.d/init.d/$_service_name ]; then
- $_nice $CTDB_SYS_ETCDIR/rc.d/init.d/$_service_name "$_op"
+ elif [ -x "${CTDB_SYS_ETCDIR}/init.d/${_service_name}" ]; then
+ $_nice "${CTDB_SYS_ETCDIR}/init.d/${_service_name}" "$_op"
+ elif [ -x "${CTDB_SYS_ETCDIR}/rc.d/init.d/${_service_name}" ]; then
+ $_nice "${CTDB_SYS_ETCDIR}/rc.d/init.d/${_service_name}" "$_op"
fi
}
######################################################
# Cached retrieval of PNN from local node. This never changes so why
# open a client connection to the server each time this is needed?
-# This sets $pnn - this avoid an unnecessary subprocess.
ctdb_get_pnn ()
{
_pnn_file="${CTDB_SCRIPT_VARDIR}/my-pnn"
if [ ! -f "$_pnn_file" ] ; then
- ctdb pnn | sed -e 's@.*:@@' >"$_pnn_file"
+ $CTDB pnn >"$_pnn_file"
fi
- read pnn <"$_pnn_file"
+ cat "$_pnn_file"
}
# Cached retrieval of private IP address from local node. This never
-# changes. Sets $ip_address to avoid an unnecessary subprocess.
+# changes.
ctdb_get_ip_address ()
{
_ip_addr_file="${CTDB_SCRIPT_VARDIR}/my-ip-address"
if [ ! -f "$_ip_addr_file" ] ; then
- ctdb -X nodestatus |
+ $CTDB -X nodestatus |
awk -F '|' 'NR == 2 { print $3 }' >"$_ip_addr_file"
fi
- read ip_address <"$_ip_addr_file"
+ # ip_address is used by caller
+ # shellcheck disable=SC2034
+ cat "$_ip_addr_file"
}
######################################################
_count=1
for _pid in $(pidof "$_prog") ; do
- [ $_count -le $_max ] || break
+ [ "$_count" -le "$_max" ] || break
# Do this first to avoid racing with process exit
_stack=$(get_proc "${_pid}/stack" 2>/dev/null)
if [ -n "$_stack" ] ; then
echo "Stack trace for ${_prog}[${_pid}]:"
echo "$_stack"
- _count=$(($_count + 1))
+ _count=$((_count + 1))
fi
done
}
# usage: ctdb_check_tcp_ports <ports...>
######################################################
-# This flag file is created when a service is initially started. It
-# is deleted the first time TCP port checks for that service succeed.
-# Until then ctdb_check_tcp_ports() prints a more subtle "error"
-# message if a port check fails.
-_ctdb_check_tcp_common ()
-{
- assert_service_name
- _d="${CTDB_SCRIPT_VARDIR}/failcount"
- _ctdb_service_started_file="${_d}/${service_name}.started"
-}
-
-ctdb_check_tcp_init ()
-{
- _ctdb_check_tcp_common
- mkdir -p "${_ctdb_service_started_file%/*}" # dirname
- touch "$_ctdb_service_started_file"
-}
-
# Check whether something is listening on all of the given TCP ports
# using the "ctdb checktcpport" command.
ctdb_check_tcp_ports()
{
- if [ -z "$1" ] ; then
- echo "INTERNAL ERROR: ctdb_check_tcp_ports - no ports specified"
- exit 1
- fi
-
- for _p ; do # process each function argument (port)
- _cmd="ctdb checktcpport $_p"
- _out=$($_cmd 2>&1)
- _ret=$?
- case "$_ret" in
- 0)
- _ctdb_check_tcp_common
- if [ ! -f "$_ctdb_service_started_file" ] ; then
- echo "ERROR: $service_name tcp port $_p is not responding"
- debug "\"ctdb checktcpport $_p\" was able to bind to port"
- else
- echo "INFO: $service_name tcp port $_p is not responding"
- fi
+ if [ -z "$1" ] ; then
+ echo "INTERNAL ERROR: ctdb_check_tcp_ports - no ports specified"
+ exit 1
+ fi
- return 1
- ;;
- 98)
- # Couldn't bind, something already listening, next port...
- continue
- ;;
- *)
- echo "ERROR: unexpected error running \"ctdb checktcpport\""
- debug <<EOF
-ctdb checktcpport (exited with $_ret) with output:
-$_out"
-EOF
- return $_ret
- esac
- done
+ for _p ; do # process each function argument (port)
+ _cmd="$CTDB checktcpport $_p"
+ _out=$($_cmd 2>&1)
+ _ret=$?
+ case "$_ret" in
+ 0)
+ echo "$service_name not listening on TCP port $_p"
+ return 1
+ ;;
+ 98)
+ # Couldn't bind, something already listening, next port
+ continue
+ ;;
+ *)
+ echo "unexpected error (${_ret}) running \"${_cmd}\""
+ if [ -n "$_out" ] ; then
+ echo "$_out"
+ fi
+ return $_ret
+ ;;
+ esac
+ done
- # All ports listening
- _ctdb_check_tcp_common
- rm -f "$_ctdb_service_started_file"
- return 0
+ # All ports listening
+ return 0
}
######################################################
fi
}
-######################################################
-# check a command returns zero status
-# usage: ctdb_check_command <command>
-######################################################
-ctdb_check_command ()
-{
- _out=$("$@" 2>&1) || {
- echo "ERROR: $* returned error"
- echo "$_out" | debug
- exit 1
- }
-}
-
################################################
# kill off any TCP connections with the given IP
################################################
139|445) __oneway=true ;;
esac
- echo "Killing TCP connection $_src $_dst"
_connections="${_connections}${_nl}${_src} ${_dst}"
if ! $__oneway ; then
_connections="${_connections}${_nl}${_dst} ${_src}"
fi
- _killcount=$(($_killcount + 1))
+ _killcount=$((_killcount + 1))
done
if [ $_killcount -eq 0 ] ; then
return
}
- _remaining=$(get_tcp_connections_for_ip $_ip | wc -l)
-
- if [ $_remaining -eq 0 ] ; then
- echo "Killed $_killcount TCP connections to released IP $_ip"
- return
+ _connections=$(get_tcp_connections_for_ip "$_ip")
+ if [ -z "$_connections" ] ; then
+ _remaining=0
+ else
+ _remaining=$(echo "$_connections" | wc -l)
fi
- _t="${_remaining}/${_killcount}"
- echo "Failed to kill TCP connections for IP $_ip (${_t} remaining)"
+ _actually_killed=$((_killcount - _remaining))
+
+ _t="${_actually_killed}/${_killcount}"
+ echo "Killed ${_t} TCP connections to released IP $_ip"
+
+ if [ -n "$_connections" ] ; then
+ echo "Remaining connections:"
+ echo "$_connections" | sed -e 's|^| |'
+ fi
}
}
{
_ip="$1"
- get_tcp_connections_for_ip "$_ip" |
- {
- _failed=false
+ # Get connections, both directions
+ _conns=$(get_tcp_connections_for_ip "$_ip" | \
+ awk '{ print $1, $2 ; print $2, $1 }')
- while read dest src; do
- echo "Tickle TCP connection $src $dest"
- ctdb tickle $src $dest >/dev/null 2>&1 || _failed=true
- echo "Tickle TCP connection $dest $src"
- ctdb tickle $dest $src >/dev/null 2>&1 || _failed=true
- done
-
- if $_failed ; then
- echo "Failed to send tickle control"
- fi
- }
+ echo "$_conns" | awk '{ print "Tickle TCP connection", $1, $2 }'
+ echo "$_conns" | ctdb tickle
}
get_tcp_connections_for_ip ()
die "Failed to bringup interface $_iface"
# Only need to define broadcast for IPv4
- case "$ip" in
+ case "$_ip" in
*:*) _bcast="" ;;
*) _bcast="brd +" ;;
esac
+ # Intentionally unquoted multi-word value here
+ # shellcheck disable=SC2086
ip addr add "$_ip/$_maskbits" $_bcast dev "$_iface" || {
echo "Failed to add $_ip/$_maskbits on dev $_iface"
return 1
*:*) _bits=128 ;;
*) _bits=32 ;;
esac
-
ip addr show to "${_addr}/${_bits}" 2>/dev/null | \
- awk 'NR == 1 { iface = $2; sub(":$", "", iface) ; \
- sub("@.*", "", iface) } \
- $1 ~ /inet/ { mask = $2; sub(".*/", "", mask); \
+ awk 'NR == 1 { iface = $2; sub(":$", "", iface) ;
+ sub("@.*", "", iface) }
+ $1 ~ /inet/ { mask = $2; sub(".*/", "", mask);
print mask, iface }'
}
{
_addr="${1%/*}" # Remove optional maskbits
- set -- $(ip_maskbits_iface $_addr)
+ # Intentional word splitting here
+ # shellcheck disable=SC2046
+ set -- $(ip_maskbits_iface "$_addr")
if [ -n "$1" ] ; then
_maskbits="$1"
_iface="$2"
echo "Removing public address $_addr/$_maskbits from device $_iface"
- delete_ip_from_iface $_iface $_addr $_maskbits >/dev/null 2>&1
+ delete_ip_from_iface "$_iface" "$_addr" "$_maskbits" >/dev/null 2>&1
fi
}
drop_all_public_ips ()
{
- while read _ip _x ; do
- drop_ip "$_ip"
- done <"${CTDB_PUBLIC_ADDRESSES:-/dev/null}"
+ # _x is intentionally ignored
+ # shellcheck disable=SC2034
+ while read _ip _x ; do
+ drop_ip "$_ip"
+ done <"${CTDB_PUBLIC_ADDRESSES:-/dev/null}"
}
flush_route_cache ()
# Extract the full interface description to see if it is a VLAN
_t=$(echo "$_iface_info" |
- awk 'NR == 1 { iface = $2; sub(":$", "", iface) ; \
+ awk 'NR == 1 { iface = $2; sub(":$", "", iface) ;
print iface }')
case "$_t" in
*@*)
_counter_file="${CTDB_SCRIPT_VARDIR}/failcount/${_service_name}"
mkdir -p "${_counter_file%/*}" # dirname
}
+# Some code passes an argument
+# shellcheck disable=SC2120
ctdb_counter_init () {
_ctdb_counter_common "$1"
ctdb_counter_incr () {
_ctdb_counter_common "$1"
- # unary counting!
- echo -n 1 >> "$_counter_file"
+ # unary counting using newlines!
+ echo >>"$_counter_file"
}
ctdb_counter_get () {
_ctdb_counter_common "$1"
# unary counting!
stat -c "%s" "$_counter_file" 2>/dev/null || echo 0
}
-ctdb_check_counter () {
- _msg="${1:-error}" # "error" - anything else is silent on fail
- _op="${2:--ge}" # an integer operator supported by test
- _limit="${3:-${service_fail_limit}}"
- shift 3
-
- _size=$(ctdb_counter_get "$1")
-
- _hit=false
- if [ "$_op" != "%" ] ; then
- if [ $_size $_op $_limit ] ; then
- _hit=true
- fi
- else
- if [ $(($_size $_op $_limit)) -eq 0 ] ; then
- _hit=true
- fi
- fi
- if $_hit ; then
- if [ "$_msg" = "error" ] ; then
- echo "ERROR: $_size consecutive failures for $_service_name, marking node unhealthy"
- exit 1
- else
- return 1
- fi
- fi
-}
########################################################
ctdb_setup_service_state_dir ()
{
- service_state_dir="${CTDB_SCRIPT_VARDIR}/service_state/${1:-${service_name}}"
- mkdir -p "$service_state_dir" || {
- echo "Error creating state dir \"$service_state_dir\""
- exit 1
- }
-}
-
-########################################################
-# Managed status history, for auto-start/stop
-
-_ctdb_managed_common ()
-{
- _ctdb_managed_file="${CTDB_SCRIPT_VARDIR}/managed_history/${service_name}"
-}
+ _s="${1:-${service_name}}"
-ctdb_service_managed ()
-{
- _ctdb_managed_common
- mkdir -p "${_ctdb_managed_file%/*}" # dirname
- touch "$_ctdb_managed_file"
-}
-
-ctdb_service_unmanaged ()
-{
- _ctdb_managed_common
- rm -f "$_ctdb_managed_file"
-}
+ _service_state_dir="${CTDB_SCRIPT_VARDIR}/service_state/${_s}"
+ mkdir -p "$_service_state_dir" ||
+ die "Error creating state dir \"${_service_state_dir}\""
-is_ctdb_previously_managed_service ()
-{
- _ctdb_managed_common
- [ -f "$_ctdb_managed_file" ]
+ echo "$_service_state_dir"
}
##################################################################
echo "Reconfiguring service \"${service_name}\"..."
ctdb_service_unset_reconfigure
service_reconfigure || return $?
+ # Intentionally have this use $service_name as default
+ # shellcheck disable=SC2119
ctdb_counter_init
}
:
}
-ctdb_reconfigure_take_lock ()
-{
- _ctdb_service_reconfigure_common
- _lock="${_d}/reconfigure_lock"
- mkdir -p "${_lock%/*}" # dirname
- touch "$_lock"
-
- (
- flock 0
- # This is overkill but will work if we need to extend this to
- # allow certain events to run multiple times in parallel
- # (e.g. takeip) and write multiple PIDs to the file.
- read _locker_event
- if [ -n "$_locker_event" ] ; then
- while read _pid ; do
- if [ -n "$_pid" -a "$_pid" != $$ ] && \
- kill -0 "$_pid" 2>/dev/null ; then
- exit 1
- fi
- done
- fi
-
- printf "%s\n%s\n" "$event_name" $$ >"$_lock"
- exit 0
- ) <"$_lock"
-}
-
-ctdb_reconfigure_release_lock ()
-{
- _ctdb_service_reconfigure_common
- _lock="${_d}/reconfigure_lock"
-
- rm -f "$_lock"
-}
-
-ctdb_replay_monitor_status ()
-{
- echo "Replaying previous status for this script due to reconfigure..."
- # Leading separator ('|') is missing in some versions...
- _out=$(ctdb scriptstatus -X | grep -E "^\|?monitor\|${script_name}\|")
- # Output looks like this:
- # |monitor|60.nfs|1|ERROR|1314764004.030861|1314764004.035514|foo bar|
- # This is the cheapest way of getting fields in the middle.
- set -- $(IFS="|" ; echo $_out)
- _code="$3"
- _status="$4"
- # The error output field can include colons so we'll try to
- # preserve them. The weak checking at the beginning tries to make
- # this work for both broken (no leading '|') and fixed output.
- _out="${_out%|}"
- _err_out="${_out#*monitor|${script_name}|*|*|*|*|}"
- case "$_status" in
- OK) : ;; # Do nothing special.
- TIMEDOUT)
- # Recast this as an error, since we can't exit with the
- # correct negative number.
- _code=1
- _err_out="[Replay of TIMEDOUT scriptstatus - note incorrect return code.] ${_err_out}"
- ;;
- DISABLED)
- # Recast this as an OK, since we can't exit with the
- # correct negative number.
- _code=0
- _err_out="[Replay of DISABLED scriptstatus - note incorrect return code.] ${_err_out}"
- ;;
- *) : ;; # Must be ERROR, do nothing special.
- esac
- if [ -n "$_err_out" ] ; then
- echo "$_err_out"
- fi
- exit $_code
-}
-
-ctdb_service_check_reconfigure ()
-{
- assert_service_name
-
- # We only care about some events in this function. For others we
- # return now.
- case "$event_name" in
- monitor|ipreallocated|reconfigure) : ;;
- *) return 0 ;;
- esac
-
- if ctdb_reconfigure_take_lock ; then
- # No events covered by this function are running, so proceed
- # with gay abandon.
- case "$event_name" in
- reconfigure)
- (ctdb_service_reconfigure)
- exit $?
- ;;
- ipreallocated)
- if ctdb_service_needs_reconfigure ; then
- ctdb_service_reconfigure
- fi
- ;;
- esac
-
- ctdb_reconfigure_release_lock
- else
- # Somebody else is running an event we don't want to collide
- # with. We proceed with caution.
- case "$event_name" in
- reconfigure)
- # Tell whoever called us to retry.
- exit 2
- ;;
- ipreallocated)
- # Defer any scheduled reconfigure and just run the
- # rest of the ipreallocated event, as per the
- # eventscript. There's an assumption here that the
- # event doesn't depend on any scheduled reconfigure.
- # This is true in the current code.
- return 0
- ;;
- monitor)
- # There is most likely a reconfigure in progress so
- # the service is possibly unstable. As above, we
- # defer any scheduled reconfigured. We also replay
- # the previous monitor status since that's the best
- # information we have.
- ctdb_replay_monitor_status
- ;;
- esac
- fi
-}
-
##################################################################
-# Does CTDB manage this service? - and associated auto-start/stop
+# Does CTDB manage this service?
ctdb_compat_managed_service ()
{
[ "${t#* ${service_name} }" != "${t}" ]
}
-ctdb_start_stop_service ()
-{
- assert_service_name
-
- # Allow service-start/service-stop pseudo-events to start/stop
- # services when we're not auto-starting/stopping and we're not
- # monitoring.
- case "$event_name" in
- service-start)
- if is_ctdb_managed_service ; then
- die 'service-start event not permitted when service is managed'
- fi
- if [ "$CTDB_SERVICE_AUTOSTARTSTOP" = "yes" ] ; then
- die 'service-start event not permitted with $CTDB_SERVICE_AUTOSTARTSTOP = yes'
- fi
- ctdb_service_start
- exit $?
- ;;
- service-stop)
- if is_ctdb_managed_service ; then
- die 'service-stop event not permitted when service is managed'
- fi
- if [ "$CTDB_SERVICE_AUTOSTARTSTOP" = "yes" ] ; then
- die 'service-stop event not permitted with $CTDB_SERVICE_AUTOSTARTSTOP = yes'
- fi
- ctdb_service_stop
- exit $?
- ;;
- esac
-
- # Do nothing unless configured to...
- [ "$CTDB_SERVICE_AUTOSTARTSTOP" = "yes" ] || return 0
-
- [ "$event_name" = "monitor" ] || return 0
-
- if is_ctdb_managed_service ; then
- if ! is_ctdb_previously_managed_service ; then
- echo "Starting service \"$service_name\" - now managed"
- background_with_logging ctdb_service_start
- exit $?
- fi
- else
- if is_ctdb_previously_managed_service ; then
- echo "Stopping service \"$service_name\" - no longer managed"
- background_with_logging ctdb_service_stop
- exit $?
- fi
- fi
-}
-
-ctdb_service_start ()
-{
- # The service is marked managed if we've ever tried to start it.
- ctdb_service_managed
-
- service_start || return $?
-
- ctdb_counter_init
- ctdb_check_tcp_init
-}
-
-ctdb_service_stop ()
-{
- ctdb_service_unmanaged
- service_stop
-}
-
# Default service_start() and service_stop() functions.
# These may be overridden in an eventscript.
##################################################################
+# This exists only for backward compatibility with 3rd party scripts
+# that call it
ctdb_standard_event_handler ()
{
:
}
# AIX (and perhaps others?) doesn't have mktemp
+# type is commonly supported and more portable than which(1)
+# shellcheck disable=SC2039
if ! type mktemp >/dev/null 2>&1 ; then
mktemp ()
{
}
fi
+######################################################################
+# NFS callout handling
+
+nfs_callout_init ()
+{
+ _state_dir="$1"
+
+ if [ -z "$CTDB_NFS_CALLOUT" ] ; then
+ CTDB_NFS_CALLOUT="${CTDB_BASE}/nfs-linux-kernel-callout"
+ fi
+ # Always export, for statd callout
+ export CTDB_NFS_CALLOUT
+
+ # If the callout wants to use this then it must create it
+ export CTDB_NFS_CALLOUT_STATE_DIR="${_state_dir}/callout-state"
+
+ # Export, if set, for use by clustered NFS callouts
+ if [ -n "$CTDB_NFS_STATE_FS_TYPE" ] ; then
+ export CTDB_NFS_STATE_FS_TYPE
+ fi
+ if [ -n "$CTDB_NFS_STATE_MNT" ] ; then
+ export CTDB_NFS_STATE_MNT
+ fi
+
+ nfs_callout_cache="${_state_dir}/nfs_callout_cache"
+ nfs_callout_cache_callout="${nfs_callout_cache}/CTDB_NFS_CALLOUT"
+ nfs_callout_cache_ops="${nfs_callout_cache}/ops"
+}
+
+nfs_callout_register ()
+{
+ mkdir -p "$nfs_callout_cache_ops"
+ rm -f "$nfs_callout_cache_ops"/*
+
+ echo "$CTDB_NFS_CALLOUT" >"$nfs_callout_cache_callout"
+
+ _t=$(eval "$CTDB_NFS_CALLOUT" "register")
+ if [ -n "$_t" ] ; then
+ echo "$_t" |
+ while IFS="" read _op ; do
+ touch "${nfs_callout_cache_ops}/${_op}"
+ done
+ else
+ touch "${nfs_callout_cache_ops}/ALL"
+ fi
+}
+
+nfs_callout ()
+{
+ # Re-run registration if $CTDB_NFS_CALLOUT has changed
+ _prev=""
+ if [ -r "$nfs_callout_cache_callout" ] ; then
+ read _prev <"$nfs_callout_cache_callout"
+ fi
+ if [ "$CTDB_NFS_CALLOUT" != "$_prev" ] ; then
+ nfs_callout_register
+ fi
+
+ # Run the operation if it is registered...
+ if [ -e "${nfs_callout_cache_ops}/${1}" ] || \
+ [ -e "${nfs_callout_cache_ops}/ALL" ]; then
+ eval "$CTDB_NFS_CALLOUT" "$@"
+ fi
+}
+
########################################################
# tickle handling
########################################################
tickledir="${CTDB_SCRIPT_VARDIR}/tickles"
mkdir -p "$tickledir"
- ctdb_get_pnn
-
# What public IPs do I hold?
- _ips=$(ctdb -X ip | awk -F'|' -v pnn=$pnn '$3 == pnn {print $2}')
+ _pnn=$(ctdb_get_pnn)
+ _ips=$($CTDB -X ip | awk -F'|' -v pnn="$_pnn" '$3 == pnn {print $2}')
# IPs and port as ss filters
_ip_filter=""
# Record our current tickles in a temporary file
_my_tickles="${tickledir}/${_port}.tickles.$$"
for _i in $_ips ; do
- ctdb -X gettickles $_i $_port |
+ $CTDB -X gettickles "$_i" "$_port" |
awk -F'|' 'NR > 1 { printf "%s:%s %s:%s\n", $2, $3, $4, $5 }'
done |
sort >"$_my_tickles"
# Add tickles for connections that we haven't already got tickles for
- comm -23 "$_my_connections" "$_my_tickles" |
- while read _src _dst ; do
- ctdb addtickle $_src $_dst
- done
+ comm -23 "$_my_connections" "$_my_tickles" | \
+ $CTDB addtickle
# Remove tickles for connections that are no longer there
- comm -13 "$_my_connections" "$_my_tickles" |
- while read _src _dst ; do
- ctdb deltickle $_src $_dst
- done
+ comm -13 "$_my_connections" "$_my_tickles" | \
+ $CTDB deltickle
rm -f "$_my_connections" "$_my_tickles"
# Remove stale files from killed scripts
- find "$tickledir" -type f -mmin +10 | xargs -r rm
+ # Files can't have spaces in name, more portable than -print0/-0
+ # shellcheck disable=SC2038
+ (cd "$tickledir" && find . -type f -mmin +10 | xargs -r rm)
}
########################################################
. "$CTDB_RC_LOCAL"
}
-[ -x $CTDB_BASE/rc.local ] && {
- . $CTDB_BASE/rc.local
+[ -x "${CTDB_BASE}/rc.local" ] && {
+ . "${CTDB_BASE}/rc.local"
}
-[ -d $CTDB_BASE/rc.local.d ] && {
- for i in $CTDB_BASE/rc.local.d/* ; do
+[ -d "${CTDB_BASE}/rc.local.d" ] && {
+ for i in "${CTDB_BASE}/rc.local.d"/* ; do
[ -x "$i" ] && . "$i"
done
}
script_name="${0##*/}" # basename
-service_fail_limit=1
-event_name="$1"