ctdb/tools/onnode

   1 #!/bin/bash
   2
   3 # Run commands on CTDB nodes.
   4
   5 # See http://ctdb.samba.org/ for more information about CTDB.
   6
   7 # Copyright (C) Martin Schwenke  2008
   8
   9 # Based on an earlier script by Andrew Tridgell and Ronnie Sahlberg.
  10
  11 # Copyright (C) Andrew Tridgell  2007
  12
  13 # This program is free software; you can redistribute it and/or modify
  14 # it under the terms of the GNU General Public License as published by
  15 # the Free Software Foundation; either version 3 of the License, or
  16 # (at your option) any later version.
  17
  18 # This program is distributed in the hope that it will be useful,
  19 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 # GNU General Public License for more details.
  22
  23 # You should have received a copy of the GNU General Public License
  24 # along with this program; if not, see <http://www.gnu.org/licenses/>.
  25
  26 prog=$(basename "$0")
  27
  28 usage ()
  29 {
  30     cat >&2 <<EOF
  31 Usage: onnode [OPTION] ... <NODES> <COMMAND> ...
  32   options:
  33     -c          Run in current working directory on specified nodes.
  34     -f          Specify nodes file, overriding default.
  35     -i          Keep standard input open - the default is to close it.
  36     -n          Allow nodes to be specified by name.
  37     -o <prefix> Save standard output from each node to file <prefix>.<ip>
  38     -p          Run command in parallel on specified nodes.
  39     -P          Push given files to nodes instead of running commands.
  40     -q          Do not print node addresses (overrides -v).
  41     -v          Print node address even for a single node.
  42   <NODES>       "all", "any", "ok" (or "healthy"), "con" (or "connected") ; or
  43                 a node number (0 base); or
  44                 a hostname (if -n is specified); or
  45                 list (comma separated) of <NODES>; or
  46                 range (hyphen separated) of node numbers.
  47 EOF
  48     exit 1
  49
  50 }
  51
  52 invalid_nodespec ()
  53 {
  54     echo "Invalid <nodespec>" >&2 ; echo >&2
  55     usage
  56 }
  57
  58 # Defaults.
  59 current=false
  60 ctdb_nodes_file=""
  61 parallel=false
  62 verbose=false
  63 quiet=false
  64 prefix=""
  65 names_ok=false
  66 push=false
  67 stdin=false
  68
  69 if [ -z "$CTDB_BASE" ] ; then
  70     CTDB_BASE="/usr/local/etc/ctdb"
  71 fi
  72
  73 . "${CTDB_BASE}/functions"
  74
  75 loadconfig
  76
  77 parse_options ()
  78 {
  79     # $POSIXLY_CORRECT means that the command passed to onnode can
  80     # take options and getopt won't reorder things to make them
  81     # options ot onnode.
  82     local temp
  83     # Not on the previous line - local returns 0!
  84     temp=$(POSIXLY_CORRECT=1 getopt -n "$prog" -o "cf:hno:pqvPi" -l help -- "$@")
  85
  86     # No! Checking the exit code afterwards is actually clearer...
  87     # shellcheck disable=SC2181
  88     [ $? -eq 0 ] || usage
  89
  90     eval set -- "$temp"
  91
  92     while true ; do
  93         case "$1" in
  94             -c) current=true ; shift ;;
  95             -f) ctdb_nodes_file="$2" ; shift 2 ;;
  96             -n) names_ok=true ; shift ;;
  97             -o) prefix="$2" ; shift 2 ;;
  98             -p) parallel=true ; shift ;;
  99             -q) quiet=true ; shift ;;
 100             -v) verbose=true ; shift ;;
 101             -P) push=true ; shift ;;
 102             -i) stdin=true ; shift ;;
 103             --) shift ; break ;;
 104             -h|--help|*) usage ;; # Shouldn't happen, so this is reasonable.
 105         esac
 106     done
 107
 108     [ $# -lt 2 ] && usage
 109
 110     nodespec="$1" ; shift
 111     command="$*"
 112 }
 113
 114 echo_nth ()
 115 {
 116     local n="$1" ; shift
 117
 118     shift "$n"
 119     local node="$1"
 120
 121     if [ -n "$node" -a "$node" != "#DEAD" ] ; then
 122         echo "$node"
 123     else
 124         echo "${prog}: \"node ${n}\" does not exist" >&2
 125         exit 1
 126     fi
 127 }
 128
 129 parse_nodespec ()
 130 {
 131     # Subshell avoids hacks to restore $IFS.
 132     (
 133         IFS=","
 134         for i in $1 ; do
 135             case "$i" in
 136                 *-*) seq "${i%-*}" "${i#*-}" 2>/dev/null || invalid_nodespec ;;
 137                 all|any|ok|healthy|con|connected) echo "$i" ;;
 138                 *)
 139                     [ "$i" -gt -1 ] 2>/dev/null || $names_ok || invalid_nodespec
 140                     echo "$i"
 141             esac
 142         done
 143     )
 144 }
 145
 146 ctdb_status_output="" # cache
 147 get_nodes_with_status ()
 148 {
 149     local all_nodes="$1"
 150     local status="$2"
 151
 152     if [ -z "$ctdb_status_output" ] ; then
 153         ctdb_status_output=$(ctdb -X status 2>&1)
 154         # No! Checking the exit code afterwards is actually clearer...
 155         # shellcheck disable=SC2181
 156         if [ $? -ne 0 ] ; then
 157             echo "${prog}: unable to get status of CTDB nodes" >&2
 158             echo "$ctdb_status_output" >&2
 159             exit 1
 160         fi
 161         local nl="
 162 "
 163         ctdb_status_output="${ctdb_status_output#*${nl}}"
 164     fi
 165
 166     (
 167         local i
 168         IFS="${IFS}|"
 169         while IFS="" read i ; do
 170
 171             # Intentional word splitting
 172             # shellcheck disable=SC2086
 173             set -- $i # split line on colons
 174             shift     # line starts with : so 1st field is empty
 175             local pnn="$1" ; shift
 176             shift # ignore IP address but need status bits below
 177
 178             case "$status" in
 179                 healthy)
 180                     # If any bit is 1, don't match this address.
 181                     local s
 182                     for s ; do
 183                         [ "$s" != "1" ] || continue 2
 184                     done
 185                     ;;
 186                 connected)
 187                     # If disconnected bit is not 0, don't match this address.
 188                     [ "$1" = "0" ] || continue
 189                     ;;
 190                 *)
 191                     invalid_nodespec
 192             esac
 193
 194             # Intentional multi-word expansion
 195             # shellcheck disable=SC2086
 196             echo_nth "$pnn" $all_nodes
 197         done <<<"$ctdb_status_output"
 198     )
 199 }
 200
 201 get_any_available_node ()
 202 {
 203     local all_nodes="$1"
 204
 205     # We do a recursive onnode to find which nodes are up and running.
 206     local out line
 207     out=$("$0" -pq all ctdb pnn 2>&1)
 208     while read line ; do
 209         if [[ "$line" =~ ^[0-9]+$ ]] ; then
 210             local pnn="$line"
 211             # Intentional multi-word expansion
 212             # shellcheck disable=SC2086
 213             echo_nth "$pnn" $all_nodes
 214             return 0
 215         fi
 216         # Else must be an error message from a down node.
 217     done <<<"$out"
 218     return 1
 219 }
 220
 221 get_nodes ()
 222 {
 223         local all_nodes
 224
 225         local f="${CTDB_BASE}/nodes"
 226         if [ -n "$ctdb_nodes_file" ] ; then
 227                 f="$ctdb_nodes_file"
 228                 if [ ! -e "$f" -a "${f#/}" = "$f" ] ; then
 229                         # $f is relative, try in $CTDB_BASE
 230                         f="${CTDB_BASE}/${f}"
 231                 fi
 232         fi
 233
 234         if [ ! -r "$f" ] ; then
 235                 echo "${prog}: unable to open nodes file  \"${f}\"" >&2
 236                 exit 1
 237         fi
 238
 239         all_nodes=$(sed -e 's@#.*@@g' -e 's@ *@@g' -e 's@^$@#DEAD@' "$f")
 240
 241         local n nodes
 242         nodes=$(parse_nodespec "$1") || exit $?
 243         for n in $nodes ; do
 244                 case "$n" in
 245                 all)
 246                         echo "${all_nodes//#DEAD/}"
 247                         ;;
 248                 any)
 249                         get_any_available_node "$all_nodes" || exit 1
 250                         ;;
 251                 ok|healthy)
 252                         get_nodes_with_status "$all_nodes" "healthy" || exit 1
 253                         ;;
 254                 con|connected)
 255                         get_nodes_with_status "$all_nodes" "connected" || exit 1
 256                         ;;
 257                 [0-9]|[0-9][0-9]|[0-9][0-9][0-9])
 258                         # Intentional multi-word expansion
 259                         # shellcheck disable=SC2086
 260                         echo_nth "$n" $all_nodes
 261                         ;;
 262                 *)
 263                         $names_ok || invalid_nodespec
 264                         echo "$n"
 265                 esac
 266         done
 267 }
 268
 269 push()
 270 {
 271     local host="$1"
 272     local files="$2"
 273
 274     local f
 275     for f in $files ; do
 276         $verbose && echo "Pushing $f"
 277         case "$f" in
 278             /*) rsync "$f" "[${host}]:${f}" ;;
 279             *)  rsync "${PWD}/${f}" "[${host}]:${PWD}/${f}" ;;
 280         esac
 281     done
 282 }
 283
 284 stdout_filter ()
 285 {
 286     if [ -n "$prefix" ] ; then
 287         cat >"${prefix}.${n//\//_}"
 288     elif $verbose && $parallel ; then
 289         sed -e "s@^@[$n] @"
 290     else
 291         cat
 292     fi
 293 }
 294
 295 stderr_filter ()
 296 {
 297     if $verbose && $parallel ; then
 298         sed -e "s@^@[$n] @"
 299     else
 300         cat
 301     fi
 302 }
 303
 304 ######################################################################
 305
 306 parse_options "$@"
 307
 308 ssh_opts=
 309 if $push ; then
 310         ONNODE_SSH=push
 311         ONNODE_SSH_OPTS=""
 312 else
 313         $current && command="cd $PWD && $command"
 314
 315         # Could "2>/dev/null || true" but want to see errors from typos in file.
 316         [ -r "${CTDB_BASE}/onnode.conf" ] && . "${CTDB_BASE}/onnode.conf"
 317         [ -n "$ONNODE_SSH" ] || ONNODE_SSH=ssh
 318         if [ "$ONNODE_SSH" = "ssh" ] ; then
 319                 if $parallel || ! $stdin ; then
 320                         ssh_opts="-n"
 321                 fi
 322         else
 323                 : # rsh? All bets are off!
 324         fi
 325 fi
 326
 327 ######################################################################
 328
 329 nodes=$(get_nodes "$nodespec") || exit $?
 330
 331 if $quiet ; then
 332     verbose=false
 333 else
 334     # If $nodes contains a space or a newline then assume multiple nodes.
 335     nl="
 336 "
 337     [ "$nodes" != "${nodes%[ ${nl}]*}" ] && verbose=true
 338 fi
 339
 340 pids=""
 341 # Intentional multi-word expansion
 342 # shellcheck disable=SC2086
 343 trap 'kill -TERM $pids 2>/dev/null' INT TERM
 344 # There's a small race here where the kill can fail if no processes
 345 # have been added to $pids and the script is interrupted.  However,
 346 # the part of the window where it matter is very small.
 347 retcode=0
 348 for n in $nodes ; do
 349         set -o pipefail 2>/dev/null
 350
 351         # The following code applies stdout_filter and stderr_filter to
 352         # the relevant streams.  Both filters are at the end of pipes so
 353         # they read from stdin and (by default) write to stdout.  To allow
 354         # the filters to operate independently, the output of
 355         # stdout_filter is sent to a temporary file descriptor (3), which
 356         # is redirected back to stdout at the outermost level.
 357         ssh_cmd="$ONNODE_SSH $ssh_opts $ONNODE_SSH_OPTS"
 358         if $parallel ; then
 359                 {
 360                         exec 3>&1
 361                         {
 362                                 $ssh_cmd "$n" "$command" 3>&- |
 363                                         stdout_filter >&3
 364                         } 2>&1 | stderr_filter
 365                 } &
 366                 pids="${pids} $!"
 367         else
 368                 if $verbose ; then
 369                         echo >&2 ; echo ">> NODE: $n <<" >&2
 370                 fi
 371
 372                 {
 373                         exec 3>&1
 374                         {
 375                                 $ssh_cmd "$n" "$command" 3>&- |
 376                                         stdout_filter >&3
 377                         } 2>&1 | stderr_filter
 378                 } || retcode=$?
 379         fi
 380 done
 381
 382 if $parallel ; then
 383         for p in $pids; do
 384                 wait "$p" || retcode=$?
 385         done
 386 fi
 387
 388 exit $retcode