ctdb/config/functions

   1 # Hey Emacs, this is a -*- shell-script -*- !!!
   2
   3 # utility functions for ctdb event scripts
   4
   5 if [ -z "$CTDB_BASE" ] ; then
   6     echo 'CTDB_BASE unset in CTDB functions file'
   7     exit 1
   8 fi
   9 export CTDB_BASE
  10
  11 # CTDB_VARDIR is used elsewhere
  12 # shellcheck disable=SC2034
  13 CTDB_VARDIR="/usr/local/var/lib/ctdb"
  14
  15 CTDB="${CTDB:-/usr/local/bin/ctdb}"
  16
  17 # Only (and always) override these variables in test code
  18
  19 if [ -z "$CTDB_SCRIPT_VARDIR" ] ; then
  20     CTDB_SCRIPT_VARDIR="/usr/local/var/lib/ctdb/scripts"
  21 fi
  22
  23 if [ -z "$CTDB_SYS_ETCDIR" ] ; then
  24     CTDB_SYS_ETCDIR="/etc"
  25 fi
  26
  27 if [ -z "$CTDB_HELPER_BINDIR" ] ; then
  28     CTDB_HELPER_BINDIR="/usr/local/libexec/ctdb"
  29 fi
  30
  31 #######################################
  32 # pull in a system config file, if any
  33
  34 load_system_config ()
  35 {
  36         for _i ; do
  37
  38                 if [ -f "${CTDB_SYS_ETCDIR}/sysconfig/${_i}" ]; then
  39                         . "${CTDB_SYS_ETCDIR}/sysconfig/${_i}"
  40                         return
  41                 elif [ -f "${CTDB_SYS_ETCDIR}/default/${_i}" ]; then
  42                         . "${CTDB_SYS_ETCDIR}/default/${_i}"
  43                         return
  44                 fi
  45         done
  46 }
  47
  48 # load_script_options [ component script ]
  49 #   script is an event script name relative to a component
  50 #   component is currently ignored
  51 load_script_options ()
  52 {
  53         if [ $# -eq 2 ] ; then
  54                 _script="$2"
  55         elif [ $# -eq 0  ] ; then
  56                 _script=""
  57         else
  58                 die "usage: load_script_options [ component script ]"
  59         fi
  60
  61         _options="${CTDB_BASE}/script.options"
  62
  63         if [ -r "$_options" ] ; then
  64                 . "$_options"
  65         fi
  66
  67         if [ -n "$_script" ] ; then
  68                 _s="${CTDB_BASE}/events/legacy/${_script}"
  69         else
  70                 _s="${0%.script}"
  71         fi
  72         _options="${_s}.options"
  73
  74         if [ -r "$_options" ] ; then
  75                 . "$_options"
  76         fi
  77 }
  78
  79 ##############################################################
  80
  81 die ()
  82 {
  83     _msg="$1"
  84     _rc="${2:-1}"
  85
  86     echo "$_msg" >&2
  87     exit "$_rc"
  88 }
  89
  90 # Log given message or stdin to either syslog or a CTDB log file
  91 # $1 is the tag passed to logger if syslog is in use.
  92 script_log ()
  93 {
  94     _tag="$1" ; shift
  95
  96     case "$CTDB_LOGGING" in
  97         file:*|"")
  98             if [ -n "$CTDB_LOGGING" ] ; then
  99                 _file="${CTDB_LOGGING#file:}"
 100             else
 101                 _file="/usr/local/var/log/log.ctdb"
 102             fi
 103             {
 104                 if [ -n "$*" ] ; then
 105                     echo "$*"
 106                 else
 107                     cat
 108                 fi
 109             } >>"$_file"
 110             ;;
 111         *)
 112             # Handle all syslog:* variants here too.  There's no tool to do
 113             # the lossy things, so just use logger.
 114             logger -t "ctdbd: ${_tag}" "$@"
 115             ;;
 116     esac
 117 }
 118
 119 # When things are run in the background in an eventscript then logging
 120 # output might get lost.  This is the "solution".  :-)
 121 background_with_logging ()
 122 {
 123     (
 124         "$@" 2>&1 </dev/null |
 125         script_log "${script_name}&"
 126     )&
 127
 128     return 0
 129 }
 130
 131 ##############################################################
 132 # check number of args for different events
 133 ctdb_check_args ()
 134 {
 135     case "$1" in
 136         takeip|releaseip)
 137             if [ $# != 4 ]; then
 138                 echo "ERROR: must supply interface, IP and maskbits"
 139                 exit 1
 140             fi
 141             ;;
 142         updateip)
 143             if [ $# != 5 ]; then
 144                 echo "ERROR: must supply old interface, new interface, IP and maskbits"
 145                 exit 1
 146             fi
 147             ;;
 148     esac
 149 }
 150
 151 ##############################################################
 152 # determine on what type of system (init style) we are running
 153 detect_init_style()
 154 {
 155         # only do detection if not already set:
 156         if [ -n "$CTDB_INIT_STYLE" ] ; then
 157                 return
 158         fi
 159
 160         if [ -x /sbin/startproc ]; then
 161                 CTDB_INIT_STYLE="suse"
 162         elif [ -x /sbin/start-stop-daemon ]; then
 163                 CTDB_INIT_STYLE="debian"
 164         else
 165                 CTDB_INIT_STYLE="redhat"
 166         fi
 167 }
 168
 169 ######################################################
 170 # simulate /sbin/service on platforms that don't have it
 171 # _service() makes it easier to hook the service() function for
 172 # testing.
 173 _service ()
 174 {
 175   _service_name="$1"
 176   _op="$2"
 177
 178   # do nothing, when no service was specified
 179   [ -z "$_service_name" ] && return
 180
 181   if [ -x /sbin/service ]; then
 182       $_nice /sbin/service "$_service_name" "$_op"
 183   elif [ -x /usr/sbin/service ]; then
 184       $_nice /usr/sbin/service "$_service_name" "$_op"
 185   elif [ -x /bin/systemctl ]; then
 186       $_nice /bin/systemctl "$_op" "$_service_name"
 187   elif [ -x "${CTDB_SYS_ETCDIR}/init.d/${_service_name}" ]; then
 188       $_nice "${CTDB_SYS_ETCDIR}/init.d/${_service_name}" "$_op"
 189   elif [ -x "${CTDB_SYS_ETCDIR}/rc.d/init.d/${_service_name}" ]; then
 190       $_nice "${CTDB_SYS_ETCDIR}/rc.d/init.d/${_service_name}" "$_op"
 191   fi
 192 }
 193
 194 service()
 195 {
 196     _nice=""
 197     _service "$@"
 198 }
 199
 200 ######################################################
 201 # simulate /sbin/service (niced) on platforms that don't have it
 202 nice_service()
 203 {
 204     _nice="nice"
 205     _service "$@"
 206 }
 207
 208 ######################################################
 209 # Cached retrieval of PNN from local node.  This never changes so why
 210 # open a client connection to the server each time this is needed?
 211 ctdb_get_pnn ()
 212 {
 213     _pnn_file="${CTDB_SCRIPT_VARDIR}/my-pnn"
 214     if [ ! -f "$_pnn_file" ] ; then
 215         $CTDB pnn >"$_pnn_file"
 216     fi
 217
 218     cat "$_pnn_file"
 219 }
 220
 221 # Cached retrieval of private IP address from local node.  This never
 222 # changes.
 223 ctdb_get_ip_address ()
 224 {
 225     _ip_addr_file="${CTDB_SCRIPT_VARDIR}/my-ip-address"
 226     if [ ! -f "$_ip_addr_file" ] ; then
 227         $CTDB -X nodestatus |
 228             awk -F '|' 'NR == 2 { print $3 }' >"$_ip_addr_file"
 229     fi
 230
 231     cat "$_ip_addr_file"
 232 }
 233
 234 # Cached retrieval of database options for use by event scripts.
 235 #
 236 # If the variables are already set then they should not be overwritten
 237 # - this should only happen during event script testing.
 238 ctdb_get_db_options ()
 239 {
 240         _db_opts_file="${CTDB_SCRIPT_VARDIR}/db_options.cache"
 241
 242         if [ ! -f "$_db_opts_file" ] ; then
 243                 {
 244                         ctdb_translate_option "database" \
 245                                               "volatile database directory" \
 246                                               "CTDB_DBDIR"
 247                         ctdb_translate_option "database" \
 248                                               "persistent database directory" \
 249                                               "CTDB_DBDIR_PERSISTENT"
 250                         ctdb_translate_option "database" \
 251                                               "state database directory" \
 252                                               "CTDB_DBDIR_STATE"
 253                 } >"$_db_opts_file"
 254         fi
 255
 256         . "$_db_opts_file"
 257 }
 258
 259 ctdb_translate_option ()
 260 {
 261         _section="$1"
 262         _opt="$2"
 263         _variable="$3"
 264
 265         # ctdb-config already prints an error if something goes wrong
 266         _t=$("${CTDB_HELPER_BINDIR}/ctdb-config" get "$_section" "$_opt") || \
 267                 exit $?
 268         echo "${_variable}=\"${_t}\""
 269 }
 270
 271 ######################################################
 272 # wrapper around /proc/ settings to allow them to be hooked
 273 # for testing
 274 # 1st arg is relative path under /proc/, 2nd arg is value to set
 275 set_proc ()
 276 {
 277     echo "$2" >"/proc/$1"
 278 }
 279
 280 set_proc_maybe ()
 281 {
 282     if [ -w "/proc/$1" ] ; then
 283         set_proc "$1" "$2"
 284     fi
 285 }
 286
 287 ######################################################
 288 # wrapper around getting file contents from /proc/ to allow
 289 # this to be hooked for testing
 290 # 1st arg is relative path under /proc/
 291 get_proc ()
 292 {
 293     cat "/proc/$1"
 294 }
 295
 296 ######################################################
 297 # Print up to $_max kernel stack traces for processes named $_program
 298 program_stack_traces ()
 299 {
 300     _prog="$1"
 301     _max="${2:-1}"
 302
 303     _count=1
 304     for _pid in $(pidof "$_prog") ; do
 305         [ "$_count" -le "$_max" ] || break
 306
 307         # Do this first to avoid racing with process exit
 308         _stack=$(get_proc "${_pid}/stack" 2>/dev/null)
 309         if [ -n "$_stack" ] ; then
 310             echo "Stack trace for ${_prog}[${_pid}]:"
 311             echo "$_stack"
 312             _count=$((_count + 1))
 313         fi
 314     done
 315 }
 316
 317 ######################################################
 318 # Ensure $service_name is set
 319 assert_service_name ()
 320 {
 321         # service_name is set by the event script
 322         # shellcheck disable=SC2154
 323         [ -n "$service_name" ] || die "INTERNAL ERROR: \$service_name not set"
 324 }
 325
 326 ######################################################
 327 # check a set of directories is available
 328 # return 1 on a missing directory
 329 # directories are read from stdin
 330 ######################################################
 331 ctdb_check_directories_probe()
 332 {
 333     while IFS="" read d ; do
 334         case "$d" in
 335             *%*)
 336                 continue
 337                 ;;
 338             *)
 339                 [ -d "${d}/." ] || return 1
 340         esac
 341     done
 342 }
 343
 344 ######################################################
 345 # check a set of directories is available
 346 # directories are read from stdin
 347 ######################################################
 348 ctdb_check_directories()
 349 {
 350     ctdb_check_directories_probe || {
 351         echo "ERROR: $service_name directory \"$d\" not available"
 352         exit 1
 353     }
 354 }
 355
 356 ######################################################
 357 # check a set of tcp ports
 358 # usage: ctdb_check_tcp_ports <ports...>
 359 ######################################################
 360
 361 # Check whether something is listening on all of the given TCP ports
 362 # using the "ctdb checktcpport" command.
 363 ctdb_check_tcp_ports()
 364 {
 365         if [ -z "$1" ] ; then
 366                 echo "INTERNAL ERROR: ctdb_check_tcp_ports - no ports specified"
 367                 exit 1
 368         fi
 369
 370         for _p ; do  # process each function argument (port)
 371                 _cmd="$CTDB checktcpport $_p"
 372                 _out=$($_cmd 2>&1)
 373                 _ret=$?
 374                 case "$_ret" in
 375                 0)
 376                         echo "$service_name not listening on TCP port $_p"
 377                         return 1
 378                         ;;
 379                 98)
 380                         # Couldn't bind, something already listening, next port
 381                         continue
 382                         ;;
 383                 *)
 384                         echo "unexpected error (${_ret}) running \"${_cmd}\""
 385                         if [ -n "$_out" ] ; then
 386                                 echo "$_out"
 387                         fi
 388                         return $_ret
 389                         ;;
 390                 esac
 391         done
 392
 393         # All ports listening
 394         return 0
 395 }
 396
 397 ######################################################
 398 # check a unix socket
 399 # usage: ctdb_check_unix_socket SOCKPATH
 400 ######################################################
 401 ctdb_check_unix_socket()
 402 {
 403         _sockpath="$1"
 404
 405         if [ -z "$_sockpath" ] ; then
 406                 echo "ERROR: ctdb_check_unix_socket() requires socket path"
 407                 return 1
 408         fi
 409
 410         _out=$(ss -l -x "src ${_sockpath}" | tail -n +2)
 411         if [ -z "$_out" ] ; then
 412                 echo "ERROR: ${service_name} not listening on ${_sockpath}"
 413                 return 1
 414         fi
 415 }
 416
 417 ################################################
 418 # kill off any TCP connections with the given IP
 419 ################################################
 420 kill_tcp_connections ()
 421 {
 422     _iface="$1"
 423     _ip="$2"
 424
 425     _oneway=false
 426     if [ "$3" = "oneway" ] ; then
 427         _oneway=true
 428     fi
 429
 430     get_tcp_connections_for_ip "$_ip" | {
 431         _killcount=0
 432         _connections=""
 433         _nl="
 434 "
 435         while read _dst _src; do
 436             _destport="${_dst##*:}"
 437             __oneway=$_oneway
 438             case $_destport in
 439                 # we only do one-way killtcp for CIFS
 440                 139|445) __oneway=true ;;
 441             esac
 442
 443             _connections="${_connections}${_nl}${_src} ${_dst}"
 444             if ! $__oneway ; then
 445                 _connections="${_connections}${_nl}${_dst} ${_src}"
 446             fi
 447
 448             _killcount=$((_killcount + 1))
 449         done
 450
 451         if [ $_killcount -eq 0 ] ; then
 452             return
 453         fi
 454
 455         if [ -n "$CTDB_KILLTCP_DEBUGLEVEL" ]; then
 456                 _debuglevel="$CTDB_KILLTCP_DEBUGLEVEL"
 457         else
 458                 _debuglevel="$CTDB_DEBUGLEVEL"
 459         fi
 460         echo "$_connections" | \
 461                 CTDB_DEBUGLEVEL="$_debuglevel" \
 462                         "${CTDB_HELPER_BINDIR}/ctdb_killtcp" "$_iface" || {
 463                 echo "Failed to kill TCP connections"
 464                 return
 465         }
 466
 467         _connections=$(get_tcp_connections_for_ip "$_ip")
 468         if [ -z "$_connections" ] ; then
 469                 _remaining=0
 470         else
 471                 _remaining=$(echo "$_connections" | wc -l)
 472         fi
 473
 474         _actually_killed=$((_killcount - _remaining))
 475
 476         _t="${_actually_killed}/${_killcount}"
 477         echo "Killed ${_t} TCP connections to released IP $_ip"
 478
 479         if [ -n "$_connections" ] ; then
 480                 echo "Remaining connections:"
 481                 echo "$_connections" | sed -e 's|^|  |'
 482         fi
 483     }
 484 }
 485
 486 ##################################################################
 487 # kill off the local end for any TCP connections with the given IP
 488 ##################################################################
 489 kill_tcp_connections_local_only ()
 490 {
 491     kill_tcp_connections "$@" "oneway"
 492 }
 493
 494 ##################################################################
 495 # tickle any TCP connections with the given IP
 496 ##################################################################
 497 tickle_tcp_connections ()
 498 {
 499     _ip="$1"
 500
 501     # Get connections, both directions
 502     _conns=$(get_tcp_connections_for_ip "$_ip" | \
 503                     awk '{ print $1, $2 ; print $2, $1 }')
 504
 505     echo "$_conns" | awk '{ print "Tickle TCP connection", $1, $2 }'
 506     echo "$_conns" | ctdb tickle
 507 }
 508
 509 get_tcp_connections_for_ip ()
 510 {
 511     _ip="$1"
 512
 513     ss -tn state established "src [$_ip]" | awk 'NR > 1 {print $3, $4}'
 514 }
 515
 516 ########################################################
 517
 518 add_ip_to_iface ()
 519 {
 520     _iface=$1
 521     _ip=$2
 522     _maskbits=$3
 523
 524     # Ensure interface is up
 525     ip link set "$_iface" up || \
 526         die "Failed to bringup interface $_iface"
 527
 528     # Only need to define broadcast for IPv4
 529     case "$_ip" in
 530         *:*) _bcast=""      ;;
 531         *)   _bcast="brd +" ;;
 532     esac
 533
 534     # Intentionally unquoted multi-word value here
 535     # shellcheck disable=SC2086
 536     ip addr add "$_ip/$_maskbits" $_bcast dev "$_iface" || {
 537         echo "Failed to add $_ip/$_maskbits on dev $_iface"
 538         return 1
 539     }
 540
 541     # Wait 5 seconds for IPv6 addresses to stop being tentative...
 542     if [ -z "$_bcast" ] ; then
 543         for _x in $(seq 1 10) ; do
 544             ip addr show to "${_ip}/128" | grep -q "tentative" || break
 545             sleep 0.5
 546         done
 547
 548         # If the address was a duplicate then it won't be on the
 549         # interface so flag an error.
 550         _t=$(ip addr show to "${_ip}/128")
 551         case "$_t" in
 552             "")
 553                 echo "Failed to add $_ip/$_maskbits on dev $_iface"
 554                 return 1
 555                 ;;
 556             *tentative*|*dadfailed*)
 557                 echo "Failed to add $_ip/$_maskbits on dev $_iface"
 558                 ip addr del "$_ip/$_maskbits" dev "$_iface"
 559                 return 1
 560                 ;;
 561         esac
 562     fi
 563 }
 564
 565 delete_ip_from_iface()
 566 {
 567     _iface=$1
 568     _ip=$2
 569     _maskbits=$3
 570
 571     # This could be set globally for all interfaces but it is probably
 572     # better to avoid surprises, so limit it the interfaces where CTDB
 573     # has public IP addresses.  There isn't anywhere else convenient
 574     # to do this so just set it each time.  This is much cheaper than
 575     # remembering and re-adding secondaries.
 576     set_proc "sys/net/ipv4/conf/${_iface}/promote_secondaries" 1
 577
 578     ip addr del "$_ip/$_maskbits" dev "$_iface" || {
 579         echo "Failed to del $_ip on dev $_iface"
 580         return 1
 581     }
 582 }
 583
 584 # If the given IP is hosted then print 2 items: maskbits and iface
 585 ip_maskbits_iface ()
 586 {
 587     _addr="$1"
 588
 589     case "$_addr" in
 590         *:*) _bits=128 ;;
 591         *)   _bits=32  ;;
 592     esac
 593     ip addr show to "${_addr}/${_bits}" 2>/dev/null | \
 594         awk 'NR == 1 { iface = $2; sub(":$", "", iface) ;
 595                        sub("@.*", "", iface) }
 596              $1 ~ /inet/ { mask = $2; sub(".*/", "", mask);
 597                            print mask, iface }'
 598 }
 599
 600 drop_ip ()
 601 {
 602     _addr="${1%/*}"  # Remove optional maskbits
 603
 604     # Intentional word splitting here
 605     # shellcheck disable=SC2046
 606     set -- $(ip_maskbits_iface "$_addr")
 607     if [ -n "$1" ] ; then
 608         _maskbits="$1"
 609         _iface="$2"
 610         echo "Removing public address $_addr/$_maskbits from device $_iface"
 611         delete_ip_from_iface "$_iface" "$_addr" "$_maskbits" >/dev/null 2>&1
 612     fi
 613 }
 614
 615 drop_all_public_ips ()
 616 {
 617         # _x is intentionally ignored
 618         # shellcheck disable=SC2034
 619         while read _ip _x ; do
 620                 case "$_ip" in
 621                 \#*) continue ;;
 622                 esac
 623                 drop_ip "$_ip"
 624         done <"${CTDB_BASE}/public_addresses"
 625 }
 626
 627 flush_route_cache ()
 628 {
 629     set_proc_maybe sys/net/ipv4/route/flush 1
 630     set_proc_maybe sys/net/ipv6/route/flush 1
 631 }
 632
 633 ########################################################
 634 # Interface monitoring
 635
 636 # If the interface is a virtual one (e.g. VLAN) then get the
 637 # underlying interface
 638 interface_get_real ()
 639 {
 640         _iface="$1"
 641
 642         # If $_iface is a VLAN (i.e. contains an '@') then strip every
 643         # before the '@', otherwise print the whole interface
 644         echo "${_iface##*@}"
 645 }
 646
 647 # Check whether an interface is operational
 648 interface_monitor ()
 649 {
 650     _iface="$1"
 651
 652     _iface_info=$(ip -br link show "$_iface" 2>&1) || {
 653         echo "ERROR: Monitored interface ${_iface} does not exist"
 654         return 1
 655     }
 656
 657
 658     # If the interface is a virtual one (e.g. VLAN) then get the
 659     # underlying interface.
 660     _realiface=$(interface_get_real "${_iface_info%% *}")
 661
 662     if _bi=$(get_proc "net/bonding/${_realiface}" 2>/dev/null) ; then
 663         # This is a bond: various monitoring strategies
 664         echo "$_bi" | grep -q 'Currently Active Slave: None' && {
 665             echo "ERROR: No active slaves for bond device ${_realiface}"
 666             return 1
 667         }
 668         echo "$_bi" | grep -q '^MII Status: up' || {
 669             echo "ERROR: public network interface ${_realiface} is down"
 670             return 1
 671         }
 672         echo "$_bi" | grep -q '^Bonding Mode: IEEE 802.3ad Dynamic link aggregation' && {
 673             # This works around a bug in the driver where the
 674             # overall bond status can be up but none of the actual
 675             # physical interfaces have a link.
 676             echo "$_bi" | grep 'MII Status:' | tail -n +2 | grep -q '^MII Status: up' || {
 677                 echo "ERROR: No active slaves for 802.ad bond device ${_realiface}"
 678                 return 1
 679             }
 680         }
 681
 682         return 0
 683     else
 684         # Not a bond
 685         case "$_iface" in
 686             lo*)
 687                 # loopback is always working
 688                 return 0
 689                 ;;
 690             ib*)
 691                 # we don't know how to test ib links
 692                 return 0
 693                 ;;
 694             *)
 695                 ethtool "$_iface" | grep -q 'Link detected: yes' || {
 696                     # On some systems, this is not successful when a
 697                     # cable is plugged but the interface has not been
 698                     # brought up previously. Bring the interface up
 699                     # and try again...
 700                     ip link set "$_iface" up
 701                     ethtool "$_iface" | grep -q 'Link detected: yes' || {
 702                         echo "ERROR: No link on the public network interface ${_iface}"
 703                         return 1
 704                     }
 705                 }
 706                 return 0
 707                 ;;
 708         esac
 709     fi
 710 }
 711
 712 ########################################################
 713 # Simple counters
 714 _ctdb_counter_common ()
 715 {
 716         [ $# -le 1 ] || die "usage: _ctdb_counter_common [name]"
 717
 718         if [ $# -eq 1 ] ; then
 719                 _counter_name="${1}.failcount"
 720         else
 721                 _counter_name="failcount"
 722         fi
 723
 724         if [ -z "$script_state_dir" ] ; then
 725                 die "ctdb_counter_* functions need ctdb_setup_state_dir()"
 726         fi
 727
 728         _counter_file="${script_state_dir}/${_counter_name}"
 729 }
 730 # Some code passes an argument
 731 # shellcheck disable=SC2120
 732 ctdb_counter_init () {
 733     _ctdb_counter_common "$1"
 734
 735     : >"$_counter_file"
 736 }
 737 ctdb_counter_incr () {
 738     _ctdb_counter_common "$1"
 739
 740     # unary counting using newlines!
 741     echo >>"$_counter_file"
 742 }
 743 ctdb_counter_get () {
 744     _ctdb_counter_common "$1"
 745     # unary counting!
 746     _val=$(wc -c < "$_counter_file" 2>/dev/null || echo 0)
 747     # Strip leading spaces from ouput of wc (on freebsd)
 748     # shellcheck disable=SC2086
 749     echo $_val
 750 }
 751
 752 ########################################################
 753
 754 # ctdb_setup_state_dir <type> <name>
 755 #   Sets/creates script_state_dir)
 756 ctdb_setup_state_dir ()
 757 {
 758         [ $# -eq 2 ] || die "usage: ctdb_setup_state_dir <type> <name>"
 759
 760         _type="$1"
 761         _name="$2"
 762
 763         script_state_dir="${CTDB_SCRIPT_VARDIR}/${_type}/${_name}"
 764
 765         mkdir -p "$script_state_dir" || \
 766                 die "Error creating script state dir \"${script_state_dir}\""
 767 }
 768
 769 ##################################################################
 770 # Reconfigure a service on demand
 771
 772 _ctdb_service_reconfigure_common ()
 773 {
 774         if [ -z "$script_state_dir" ] ; then
 775                 die "ctdb_service_*_reconfigure() needs ctdb_setup_state_dir()"
 776         fi
 777
 778         _ctdb_service_reconfigure_flag="${script_state_dir}/need_reconfigure"
 779 }
 780
 781 ctdb_service_needs_reconfigure ()
 782 {
 783     _ctdb_service_reconfigure_common
 784     [ -e "$_ctdb_service_reconfigure_flag" ]
 785 }
 786
 787 ctdb_service_set_reconfigure ()
 788 {
 789     _ctdb_service_reconfigure_common
 790     : >"$_ctdb_service_reconfigure_flag"
 791 }
 792
 793 ctdb_service_unset_reconfigure ()
 794 {
 795     _ctdb_service_reconfigure_common
 796     rm -f "$_ctdb_service_reconfigure_flag"
 797 }
 798
 799 ctdb_service_reconfigure ()
 800 {
 801     echo "Reconfiguring service \"${service_name}\"..."
 802     ctdb_service_unset_reconfigure
 803     service_reconfigure || return $?
 804     # Intentionally have this use $service_name as default
 805     # shellcheck disable=SC2119
 806     ctdb_counter_init
 807 }
 808
 809 # Default service_reconfigure() function does nothing.
 810 service_reconfigure ()
 811 {
 812     :
 813 }
 814
 815 # Default service_start() and service_stop() functions.
 816
 817 # These may be overridden in an eventscript.
 818 service_start ()
 819 {
 820     service "$service_name" start
 821 }
 822
 823 service_stop ()
 824 {
 825     service "$service_name" stop
 826 }
 827
 828 ##################################################################
 829
 830 # This exists only for backward compatibility with 3rd party scripts
 831 # that call it
 832 ctdb_standard_event_handler ()
 833 {
 834     :
 835 }
 836
 837 iptables_wrapper ()
 838 {
 839     _family="$1" ; shift
 840     if [ "$_family" = "inet6" ] ; then
 841         _iptables_cmd="ip6tables"
 842     else
 843         _iptables_cmd="iptables"
 844     fi
 845
 846     # iptables doesn't like being re-entered, so flock-wrap it.
 847     flock -w 30 "${CTDB_SCRIPT_VARDIR}/iptables.flock" "$_iptables_cmd" "$@"
 848 }
 849
 850 # AIX (and perhaps others?) doesn't have mktemp
 851 # type is commonly supported and more portable than which(1)
 852 # shellcheck disable=SC2039
 853 if ! type mktemp >/dev/null 2>&1 ; then
 854     mktemp ()
 855     {
 856         _dir=false
 857         if [ "$1" = "-d" ] ; then
 858             _dir=true
 859             shift
 860         fi
 861         _d="${TMPDIR:-/tmp}"
 862         _hex10=$(dd if=/dev/urandom count=20 2>/dev/null | \
 863             cksum | \
 864             awk '{print $1}')
 865         _t="${_d}/tmp.${_hex10}"
 866         (
 867             umask 077
 868             if $_dir ; then
 869                 mkdir "$_t"
 870             else
 871                 : >"$_t"
 872             fi
 873         )
 874         echo "$_t"
 875     }
 876 fi
 877
 878 ######################################################################
 879 # NFS callout handling
 880
 881 nfs_callout_init ()
 882 {
 883         _state_dir="$1"
 884
 885         if [ -z "$CTDB_NFS_CALLOUT" ] ; then
 886                 CTDB_NFS_CALLOUT="${CTDB_BASE}/nfs-linux-kernel-callout"
 887         fi
 888         # Always export, for statd callout
 889         export CTDB_NFS_CALLOUT
 890
 891         # If the callout wants to use this then it must create it
 892         export CTDB_NFS_CALLOUT_STATE_DIR="${_state_dir}/callout-state"
 893
 894         # Export, if set, for use by clustered NFS callouts
 895         if [ -n "$CTDB_NFS_STATE_FS_TYPE" ] ; then
 896                 export CTDB_NFS_STATE_FS_TYPE
 897         fi
 898         if [ -n "$CTDB_NFS_STATE_MNT" ] ; then
 899                 export CTDB_NFS_STATE_MNT
 900         fi
 901
 902         nfs_callout_cache="${_state_dir}/nfs_callout_cache"
 903         nfs_callout_cache_callout="${nfs_callout_cache}/CTDB_NFS_CALLOUT"
 904         nfs_callout_cache_ops="${nfs_callout_cache}/ops"
 905 }
 906
 907 nfs_callout_register ()
 908 {
 909     mkdir -p "$nfs_callout_cache_ops"
 910     rm -f "$nfs_callout_cache_ops"/*
 911
 912     echo "$CTDB_NFS_CALLOUT" >"$nfs_callout_cache_callout"
 913
 914     _t=$("$CTDB_NFS_CALLOUT" "register")
 915     if [ -n "$_t" ] ; then
 916         echo "$_t" |
 917             while IFS="" read _op ; do
 918                 touch "${nfs_callout_cache_ops}/${_op}"
 919             done
 920     else
 921         touch "${nfs_callout_cache_ops}/ALL"
 922     fi
 923 }
 924
 925 nfs_callout ()
 926 {
 927     # Re-run registration if $CTDB_NFS_CALLOUT has changed
 928     _prev=""
 929     if [ -r "$nfs_callout_cache_callout" ] ; then
 930         read _prev <"$nfs_callout_cache_callout"
 931     fi
 932     if [ "$CTDB_NFS_CALLOUT" != "$_prev" ] ; then
 933         nfs_callout_register
 934     fi
 935
 936     # Run the operation if it is registered...
 937     if [ -e "${nfs_callout_cache_ops}/${1}" ] || \
 938            [ -e "${nfs_callout_cache_ops}/ALL" ]; then
 939         "$CTDB_NFS_CALLOUT" "$@"
 940     fi
 941 }
 942
 943 ########################################################
 944 # tickle handling
 945 ########################################################
 946
 947 update_tickles ()
 948 {
 949         _port="$1"
 950
 951         tickledir="${CTDB_SCRIPT_VARDIR}/tickles"
 952         mkdir -p "$tickledir"
 953
 954         # What public IPs do I hold?
 955         _pnn=$(ctdb_get_pnn)
 956         _ips=$($CTDB -X ip | awk -F'|' -v pnn="$_pnn" '$3 == pnn {print $2}')
 957
 958         # IPs and port as ss filters
 959         _ip_filter=""
 960         for _ip in $_ips ; do
 961             _ip_filter="${_ip_filter}${_ip_filter:+ || }src [${_ip}]"
 962         done
 963         _port_filter="sport == :${_port}"
 964
 965         # Record connections to our public IPs in a temporary file.
 966         # This temporary file is in CTDB's private state directory and
 967         # $$ is used to avoid a very rare race involving CTDB's script
 968         # debugging.  No security issue, nothing to see here...
 969         _my_connections="${tickledir}/${_port}.connections.$$"
 970         # Parentheses are needed around the filters for precedence but
 971         # the parentheses can't be empty!
 972         #
 973         # Recent versions of ss print square brackets around IPv6
 974         # addresses.  While it is desirable to update CTDB's address
 975         # parsing and printing code, something needs to be done here
 976         # for backward compatibility, so just delete the brackets.
 977         ss -tn state established \
 978            "${_ip_filter:+( ${_ip_filter} )}" \
 979            "${_port_filter:+( ${_port_filter} )}" |
 980         awk 'NR > 1 {print $4, $3}' |
 981         tr -d '][' |
 982         sort >"$_my_connections"
 983
 984         # Record our current tickles in a temporary file
 985         _my_tickles="${tickledir}/${_port}.tickles.$$"
 986         for _i in $_ips ; do
 987                 $CTDB -X gettickles "$_i" "$_port" |
 988                 awk -F'|' 'NR > 1 { printf "%s:%s %s:%s\n", $2, $3, $4, $5 }'
 989         done |
 990         sort >"$_my_tickles"
 991
 992         # Add tickles for connections that we haven't already got tickles for
 993         comm -23 "$_my_connections" "$_my_tickles" | \
 994                 $CTDB addtickle
 995
 996         # Remove tickles for connections that are no longer there
 997         comm -13 "$_my_connections" "$_my_tickles" | \
 998                 $CTDB deltickle
 999
1000         rm -f "$_my_connections" "$_my_tickles"
1001
1002         # Remove stale files from killed scripts
1003         # Files can't have spaces in name, more portable than -print0/-0
1004         # shellcheck disable=SC2038
1005         (cd "$tickledir" && find . -type f -mmin +10 | xargs -r rm)
1006 }
1007
1008 ########################################################
1009 # load a site local config file
1010 ########################################################
1011
1012 [ -x "${CTDB_BASE}/rc.local" ] && {
1013         . "${CTDB_BASE}/rc.local"
1014 }
1015
1016 [ -d "${CTDB_BASE}/rc.local.d" ] && {
1017         for i in "${CTDB_BASE}/rc.local.d"/* ; do
1018                 [ -x "$i" ] && . "$i"
1019         done
1020 }
1021
1022 script_name="${0##*/}"       # basename