ctdb/tests/eventscripts/scripts/local.sh

   1 # Hey Emacs, this is a -*- shell-script -*- !!!  :-)
   2
   3 # Augment PATH with relevant stubs/ directories.  We do this by actually
   4 # setting PATH, and also by setting $EVENTSCRIPTS_PATH and then
   5 # prepending that to $PATH in rc.local to avoid the PATH reset in
   6 # functions.
   7
   8 EVENTSCRIPTS_PATH=""
   9
  10 if [ -d "${TEST_SUBDIR}/stubs" ] ; then
  11     EVENTSCRIPTS_PATH="${TEST_SUBDIR}/stubs"
  12 fi
  13
  14 export EVENTSCRIPTS_PATH
  15
  16 PATH="${EVENTSCRIPTS_PATH}:${PATH}"
  17
  18 export EVENTSCRIPTS_TESTS_VAR_DIR="${TEST_VAR_DIR}/unit_eventscripts"
  19 if [ -d "$EVENTSCRIPTS_TESTS_VAR_DIR" -a \
  20     "$EVENTSCRIPTS_TESTS_VAR_DIR" != "/unit_eventscripts" ] ; then
  21     rm -r "$EVENTSCRIPTS_TESTS_VAR_DIR"
  22 fi
  23 mkdir -p "$EVENTSCRIPTS_TESTS_VAR_DIR"
  24 export CTDB_VARDIR="$EVENTSCRIPTS_TESTS_VAR_DIR/ctdb"
  25
  26 export CTDB_LOGFILE="${EVENTSCRIPTS_TESTS_VAR_DIR}/log.ctdb"
  27 touch "$CTDB_LOGFILE" || die "Unable to create CTDB_LOGFILE=$CTDB_LOGFILE"
  28
  29 if [ -d "${TEST_SUBDIR}/etc" ] ; then
  30     cp -a "${TEST_SUBDIR}/etc" "$EVENTSCRIPTS_TESTS_VAR_DIR"
  31     export CTDB_ETCDIR="${EVENTSCRIPTS_TESTS_VAR_DIR}/etc"
  32 else
  33     die "Unable to setup \$CTDB_ETCDIR"
  34 fi
  35
  36 if [ -d "${TEST_SUBDIR}/etc-ctdb" ] ; then
  37     cp -prL "${TEST_SUBDIR}/etc-ctdb" "$EVENTSCRIPTS_TESTS_VAR_DIR"
  38     export CTDB_BASE="${EVENTSCRIPTS_TESTS_VAR_DIR}/etc-ctdb"
  39 else
  40     die "Unable to set \$CTDB_BASE"
  41 fi
  42 export CTDB_BASE
  43
  44 if [ ! -d "${CTDB_BASE}/events.d" ] ; then
  45     cat <<EOF
  46 ERROR: Directory ${CTDB_BASE}/events.d does not exist.
  47
  48 That means that no eventscripts can be tested.
  49
  50 One possible explanation:
  51
  52   You have CTDB installed via RPMs (or similar), so the regular
  53   CTDB_BASE directory is in /etc/ctdb/
  54
  55   BUT
  56
  57   You have done a regular "configure" and "make install" so the tests
  58   are installed under /usr/local/.
  59
  60 If so, one possible hack to fix this is to create a symlink:
  61
  62   ln -s /etc/ctdb /usr/local/etc/ctdb
  63
  64 This is nasty but it works...  :-)
  65 EOF
  66     exit 1
  67 fi
  68
  69 ######################################################################
  70
  71 if "$TEST_VERBOSE" ; then
  72     debug () { echo "$@" ; }
  73 else
  74     debug () { : ; }
  75 fi
  76
  77 eventscripts_tests_cleanup_hooks=""
  78
  79 # This loses quoting!
  80 eventscripts_test_add_cleanup ()
  81 {
  82     eventscripts_tests_cleanup_hooks="${eventscripts_tests_cleanup_hooks}${eventscripts_tests_cleanup_hooks:+ ; }$*"
  83 }
  84
  85 trap 'eval $eventscripts_tests_cleanup_hooks' 0
  86
  87
  88 ######################################################################
  89
  90 # General setup fakery
  91
  92 setup_generic ()
  93 {
  94     debug "Setting up shares (3 existing shares)"
  95     # Create 3 fake shares/exports.
  96     export FAKE_SHARES=""
  97     for i in $(seq 1 3) ; do
  98         _s="${EVENTSCRIPTS_TESTS_VAR_DIR}/shares/${i}_existing"
  99         mkdir -p "$_s"
 100         FAKE_SHARES="${FAKE_SHARES}${FAKE_SHARES:+ }${_s}"
 101     done
 102
 103     export FAKE_PROC_NET_BONDING="$EVENTSCRIPTS_TESTS_VAR_DIR/proc-net-bonding"
 104     mkdir -p "$FAKE_PROC_NET_BONDING"
 105     rm -f "$FAKE_PROC_NET_BONDING"/*
 106
 107     export FAKE_ETHTOOL_LINK_DOWN="$EVENTSCRIPTS_TESTS_VAR_DIR/ethtool-link-down"
 108     mkdir -p "$FAKE_ETHTOOL_LINK_DOWN"
 109     rm -f "$FAKE_ETHTOOL_LINK_DOWN"/*
 110
 111     # This can only have 2 levels.  We don't want to resort to usings
 112     # something dangerous like "rm -r" setup time.
 113     export FAKE_IP_STATE="$EVENTSCRIPTS_TESTS_VAR_DIR/fake-ip-state"
 114     mkdir -p "$FAKE_IP_STATE"
 115     rm -f "$FAKE_IP_STATE"/*/*
 116     rm -f "$FAKE_IP_STATE"/* 2>/dev/null || true
 117     rmdir "$FAKE_IP_STATE"/* 2>/dev/null || true
 118
 119
 120     export CTDB_DBDIR="${EVENTSCRIPTS_TESTS_VAR_DIR}/db"
 121     mkdir -p "${CTDB_DBDIR}/persistent"
 122
 123     export FAKE_TDBTOOL_SUPPORTS_CHECK="yes"
 124     export FAKE_TDB_IS_OK
 125     export FAKE_DATE_OUTPUT
 126
 127     export FAKE_NETSTAT_TCP_ESTABLISHED FAKE_TCP_LISTEN FAKE_NETSTAT_UNIX_LISTEN
 128     export FAKE_NETSTAT_TCP_ESTABLISHED_FILE=$(mktemp --tmpdir="$EVENTSCRIPTS_TESTS_VAR_DIR")
 129 }
 130
 131 tcp_port_down ()
 132 {
 133     for _i ; do
 134         debug "Marking TCP port \"${_i}\" as not listening"
 135         FAKE_TCP_LISTEN=$(echo "$FAKE_TCP_LISTEN" | sed -r -e "s@[[:space:]]*[\.0-9]+:${_i}@@g")
 136     done
 137 }
 138
 139 shares_missing ()
 140 {
 141     _fmt="$1" ; shift
 142
 143     # Replace some shares with non-existent ones.
 144     _t=""
 145     _n=1
 146     _nl="
 147 "
 148     export MISSING_SHARES_TEXT=""
 149     for _i in $FAKE_SHARES ; do
 150         if [ $_n = "$1" ] ; then
 151             shift
 152             _i="${_i%_existing}_missing"
 153             debug "Replacing share $_n with missing share \"$_i\""
 154             rmdir "$_i" 2>/dev/null || true
 155             MISSING_SHARES_TEXT="${MISSING_SHARES_TEXT}${MISSING_SHARES_TEXT:+${_nl}}"$(printf "$_fmt" "${_i}")
 156         fi
 157         _t="${_t}${_t:+ }${_i}"
 158         _n=$(($_n + 1))
 159     done
 160     FAKE_SHARES="$_t"
 161 }
 162
 163 # Setup some fake /proc/net/bonding files with just enough info for
 164 # the eventscripts.
 165
 166 # arg1 is interface name, arg2 is currently active slave (use "None"
 167 # if none), arg3 is MII status ("up" or "down").
 168 setup_bond ()
 169 {
 170     _iface="$1"
 171     _slave="${2:-${_iface}_sl_0}"
 172     _mii_s="${3:-up}"
 173     _mii_subs="${4:-${_mii_s:-up}}"
 174     echo "Setting $_iface to be a bond with active slave $_slave and MII status $_mii_s"
 175     cat >"${FAKE_PROC_NET_BONDING}/$_iface" <<EOF
 176 Bonding Mode: IEEE 802.3ad Dynamic link aggregation
 177 Currently Active Slave: $_slave
 178 # Status of the bond
 179 MII Status: $_mii_s
 180 # Status of 1st pretend adapter
 181 MII Status: $_mii_subs
 182 # Status of 2nd pretend adapter
 183 MII Status: $_mii_subs
 184 EOF
 185 }
 186
 187 ethtool_interfaces_down ()
 188 {
 189     for _i ; do
 190         echo "Marking interface $_i DOWN for ethtool"
 191         touch "${FAKE_ETHTOOL_LINK_DOWN}/${_i}"
 192     done
 193 }
 194
 195 ethtool_interfaces_up ()
 196 {
 197     for _i ; do
 198         echo "Marking interface $_i UP for ethtool"
 199         rm -f "${FAKE_ETHTOOL_LINK_DOWN}/${_i}"
 200     done
 201 }
 202
 203 dump_routes ()
 204 {
 205     echo "# ip rule show"
 206     ip rule show
 207
 208     ip rule show |
 209     while read _p _x _i _x _t ; do
 210         # Remove trailing colon after priority/preference.
 211         _p="${_p%:}"
 212         # Only remove rules that match our priority/preference.
 213         [ "$CTDB_PER_IP_ROUTING_RULE_PREF" = "$_p" ] || continue
 214
 215         echo "# ip route show table $_t"
 216         ip route show table "$_t"
 217     done
 218 }
 219
 220 # Copied from 13.per_ip_routing for now... so this is lazy testing  :-(
 221 ipv4_host_addr_to_net ()
 222 {
 223     _host="$1"
 224     _maskbits="$2"
 225
 226     # Convert the host address to an unsigned long by splitting out
 227     # the octets and doing the math.
 228     _host_ul=0
 229     for _o in $(export IFS="." ; echo $_host) ; do
 230         _host_ul=$(( ($_host_ul << 8) + $_o)) # work around Emacs color bug
 231     done
 232
 233     # Calculate the mask and apply it.
 234     _mask_ul=$(( 0xffffffff << (32 - $_maskbits) ))
 235     _net_ul=$(( $_host_ul & $_mask_ul ))
 236
 237     # Now convert to a network address one byte at a time.
 238     _net=""
 239     for _o in $(seq 1 4) ; do
 240         _net="$(($_net_ul & 255))${_net:+.}${_net}"
 241         _net_ul=$(($_net_ul >> 8))
 242     done
 243
 244     echo "${_net}/${_maskbits}"
 245 }
 246
 247 ######################################################################
 248
 249 # CTDB fakery
 250
 251 # Evaluate an expression that probably calls functions or uses
 252 # variables from the CTDB functions file.  This is used for test
 253 # initialisation.
 254 eventscript_call ()
 255 {
 256     (
 257         . "$CTDB_BASE/functions"
 258         "$@"
 259     )
 260 }
 261
 262 # Set output for ctdb command.  Option 1st argument is return code.
 263 ctdb_set_output ()
 264 {
 265     _out="$EVENTSCRIPTS_TESTS_VAR_DIR/ctdb.out"
 266     cat >"$_out"
 267
 268     _rc="$EVENTSCRIPTS_TESTS_VAR_DIR/ctdb.rc"
 269     echo "${1:-0}" >"$_rc"
 270
 271     eventscripts_test_add_cleanup "rm -f $_out $_rc"
 272 }
 273
 274 setup_ctdb ()
 275 {
 276     setup_generic
 277
 278     export FAKE_CTDB_NUMNODES="${1:-3}"
 279     echo "Setting up CTDB with ${FAKE_CTDB_NUMNODES} fake nodes"
 280
 281     export FAKE_CTDB_PNN="${2:-0}"
 282     echo "Setting up CTDB with PNN ${FAKE_CTDB_PNN}"
 283
 284     export CTDB_PUBLIC_ADDRESSES="${CTDB_BASE}/public_addresses"
 285     if [ -n "$3" ] ; then
 286         echo "Setting up CTDB_PUBLIC_ADDRESSES: $3"
 287         CTDB_PUBLIC_ADDRESSES=$(mktemp)
 288         for _i in $3 ; do
 289             _ip="${_i%@*}"
 290             _ifaces="${_i#*@}"
 291             echo "${_ip} ${_ifaces}" >>"$CTDB_PUBLIC_ADDRESSES"
 292         done
 293         eventscripts_test_add_cleanup "rm -f $CTDB_PUBLIC_ADDRESSES"
 294     fi
 295
 296     export FAKE_CTDB_STATE="$EVENTSCRIPTS_TESTS_VAR_DIR/fake-ctdb"
 297
 298     export FAKE_CTDB_IFACES_DOWN="$FAKE_CTDB_STATE/ifaces-down"
 299     mkdir -p "$FAKE_CTDB_IFACES_DOWN"
 300     rm -f "$FAKE_CTDB_IFACES_DOWN"/*
 301
 302     export FAKE_CTDB_SCRIPTSTATUS="$FAKE_CTDB_STATE/scriptstatus"
 303     mkdir -p "$FAKE_CTDB_SCRIPTSTATUS"
 304     rm -f "$FAKE_CTDB_SCRIPTSTATUS"/*
 305
 306     export CTDB_PARTIALLY_ONLINE_INTERFACES
 307 }
 308
 309 setup_memcheck ()
 310 {
 311     setup_ctdb
 312
 313     _swap_total="5857276"
 314
 315     if [ "$1" = "bad" ] ; then
 316         _swap_free="   4352"
 317         _mem_cached=" 112"
 318         _mem_free=" 468"
 319     else
 320         _swap_free="$_swap_total"
 321         _mem_cached="1112"
 322         _mem_free="1468"
 323     fi
 324
 325     export FAKE_PROC_MEMINFO="\
 326 MemTotal:        3940712 kB
 327 MemFree:          225268 kB
 328 Buffers:          146120 kB
 329 Cached:          1139348 kB
 330 SwapCached:        56016 kB
 331 Active:          2422104 kB
 332 Inactive:        1019928 kB
 333 Active(anon):    1917580 kB
 334 Inactive(anon):   523080 kB
 335 Active(file):     504524 kB
 336 Inactive(file):   496848 kB
 337 Unevictable:        4844 kB
 338 Mlocked:            4844 kB
 339 SwapTotal:       ${_swap_total} kB
 340 SwapFree:        ${_swap_free} kB
 341 ..."
 342
 343     export FAKE_FREE_M="\
 344              total       used       free     shared    buffers     cached
 345 Mem:          3848       3634        213          0        142       ${_mem_cached}
 346 -/+ buffers/cache:       2379       ${_mem_free}
 347 Swap:         5719        246       5473"
 348
 349     export CTDB_MONITOR_FREE_MEMORY
 350     export CTDB_MONITOR_FREE_MEMORY_WARN
 351     export CTDB_CHECK_SWAP_IS_NOT_USED
 352 }
 353
 354 ctdb_get_interfaces ()
 355 {
 356     # The echo/subshell forces all the output onto 1 line.
 357     echo $(ctdb ifaces -Y | awk -F: 'FNR > 1 {print $2}')
 358 }
 359
 360 ctdb_get_1_interface ()
 361 {
 362     _t=$(ctdb_get_interfaces)
 363     echo ${_t%% *}
 364 }
 365
 366 # Print all public addresses as: interface IP maskbits
 367 # Each line is suitable for passing to takeip/releaseip
 368 ctdb_get_all_public_addresses ()
 369 {
 370     _f="${CTDB_PUBLIC_ADDRESSES:-${CTDB_BASE}/public_addresses}"
 371     while IFS="/$IFS" read _ip _maskbits _ifaces ; do
 372         echo "$_ifaces $_ip $_maskbits"
 373     done <"$_f"
 374 }
 375
 376 # Print public addresses on this node as: interface IP maskbits
 377 # Each line is suitable for passing to takeip/releaseip
 378 ctdb_get_my_public_addresses ()
 379 {
 380     ctdb ip -v -Y | {
 381         read _x # skip header line
 382
 383         while IFS=":" read _x _ip _x _iface _x ; do
 384             [ -n "$_iface" ] || continue
 385             while IFS="/$IFS" read _i _maskbits _x ; do
 386                 if [ "$_ip" = "$_i" ] ; then
 387                     echo $_iface $_ip $_maskbits
 388                     break
 389                 fi
 390             done <"${CTDB_PUBLIC_ADDRESSES:-${CTDB_BASE}/public_addresses}"
 391         done
 392     }
 393 }
 394
 395 # Prints the 1st public address as: interface IP maskbits
 396 # This is suitable for passing to takeip/releaseip
 397 ctdb_get_1_public_address ()
 398 {
 399     ctdb_get_my_public_addresses | { head -n 1 ; cat >/dev/null ; }
 400 }
 401
 402 ctdb_not_implemented ()
 403 {
 404     export CTDB_NOT_IMPLEMENTED="$1"
 405     ctdb_not_implemented="\
 406 DEBUG: ctdb: command \"$1\" not implemented in stub"
 407 }
 408
 409 ctdb_fake_scriptstatus ()
 410 {
 411     _code="$1"
 412     _status="$2"
 413     _err_out="$3"
 414
 415     _d1=$(date '+%s.%N')
 416     _d2=$(date '+%s.%N')
 417
 418     echo "$_code $_status $_err_out" >"$FAKE_CTDB_SCRIPTSTATUS/$script"
 419 }
 420
 421 ######################################################################
 422
 423 setup_ctdb_policy_routing ()
 424 {
 425     service_name="per_ip_routing"
 426
 427     export CTDB_PER_IP_ROUTING_CONF="$CTDB_BASE/policy_routing"
 428     export CTDB_PER_IP_ROUTING_RULE_PREF=100
 429     export CTDB_PER_IP_ROUTING_TABLE_ID_LOW=1000
 430     export CTDB_PER_IP_ROUTING_TABLE_ID_HIGH=2000
 431
 432     # Tests need to create and populate this file
 433     rm -f "$CTDB_PER_IP_ROUTING_CONF"
 434 }
 435
 436 # Create policy routing configuration in $CTDB_PER_IP_ROUTING_CONF.
 437 # $1 is the number of assigned IPs to use (<num>, all), defaulting to
 438 # 1.  If $2 is "default" then a default route is also added.
 439 create_policy_routing_config ()
 440 {
 441     _num_ips="${1:-1}"
 442     _should_add_default="$2"
 443
 444     ctdb_get_my_public_addresses |
 445     if [ "$_num_ips" = "all" ] ; then
 446         cat
 447     else
 448         { head -n "$_num_ips" ; cat >/dev/null ; }
 449     fi |
 450     while read _dev _ip _bits ; do
 451         _net=$(ipv4_host_addr_to_net "$_ip" "$_bits")
 452         _gw="${_net%.*}.1" # a dumb, calculated default
 453
 454         echo "$_ip $_net"
 455
 456         if [ "$_should_add_default" = "default" ] ; then
 457             echo "$_ip 0.0.0.0/0 $_gw"
 458         fi
 459     done >"$CTDB_PER_IP_ROUTING_CONF"
 460 }
 461
 462 # Check the routes against those that are expected.  $1 is the number
 463 # of assigned IPs to use (<num>, all), defaulting to 1.  If $2 is
 464 # "default" then expect default routes to have been added.
 465 check_routes ()
 466 {
 467     _num_ips="${1:-1}"
 468     _should_add_default="$2"
 469
 470     _policy_rules=""
 471     _policy_routes=""
 472
 473     ctdb_get_my_public_addresses |
 474     if [ "$_num_ips" = "all" ] ; then
 475         cat
 476     else
 477         { head -n "$_num_ips" ; cat >/dev/null ; }
 478     fi | {
 479         while read _dev _ip _bits ; do
 480             _net=$(ipv4_host_addr_to_net "$_ip" "$_bits")
 481             _gw="${_net%.*}.1" # a dumb, calculated default
 482
 483             _policy_rules="${_policy_rules}
 484 ${CTDB_PER_IP_ROUTING_RULE_PREF}:       from $_ip lookup ctdb.$_ip "
 485             _policy_routes="${_policy_routes}
 486 # ip route show table ctdb.$_ip
 487 $_net dev $_dev  scope link "
 488
 489             if [ "$_should_add_default" = "default" ] ; then
 490                 _policy_routes="${_policy_routes}
 491 default via $_gw dev $_dev "
 492             fi
 493         done
 494
 495         ok <<EOF
 496 # ip rule show
 497 0:      from all lookup local ${_policy_rules}
 498 32766:  from all lookup main
 499 32767:  from all lookup default ${_policy_routes}
 500 EOF
 501
 502         simple_test_command dump_routes
 503     }
 504 }
 505
 506 ######################################################################
 507
 508 # Samba/winbind fakery
 509
 510 setup_samba ()
 511 {
 512     setup_ctdb
 513
 514     service_name="samba"
 515
 516     if [ "$1" != "down" ] ; then
 517
 518         debug "Marking Samba services as up, listening and managed by CTDB"
 519         # Get into known state.
 520         eventscript_call ctdb_service_managed
 521
 522         # All possible service names for all known distros.
 523         for i in "smb" "nmb" "samba" ; do
 524             service "$i" force-started
 525         done
 526
 527         export CTDB_SAMBA_SKIP_SHARE_CHECK="no"
 528         export CTDB_MANAGED_SERVICES="foo samba bar"
 529
 530         export FAKE_TCP_LISTEN="0.0.0.0:445 0.0.0.0:139"
 531         export FAKE_WBINFO_FAIL="no"
 532
 533         # Some things in 50.samba are backgrounded and waited for.  If
 534         # we don't sleep at all then timeouts can happen.  This avoids
 535         # that...  :-)
 536         export FAKE_SLEEP_FORCE=0.1
 537     else
 538         debug "Marking Samba services as down, not listening and not managed by CTDB"
 539         # Get into known state.
 540         eventscript_call ctdb_service_unmanaged
 541
 542         # All possible service names for all known distros.
 543         for i in "smb" "nmb" "samba" ; do
 544             service "$i" force-stopped
 545         done
 546
 547         export CTDB_SAMBA_SKIP_SHARE_CHECK="no"
 548         export CTDB_MANAGED_SERVICES="foo bar"
 549         unset CTDB_MANAGES_SAMBA
 550
 551         export FAKE_TCP_LISTEN=""
 552         export FAKE_WBINFO_FAIL="yes"
 553     fi
 554
 555     # This is ugly but if this file isn't removed before each test
 556     # then configuration changes between tests don't stick.
 557     rm -f "$CTDB_VARDIR/state/samba/smb.conf.cache"
 558 }
 559
 560 setup_winbind ()
 561 {
 562     setup_ctdb
 563
 564     service_name="winbind"
 565
 566     if [ "$1" != "down" ] ; then
 567
 568         debug "Marking Winbind service as up and managed by CTDB"
 569         # Get into known state.
 570         eventscript_call ctdb_service_managed
 571
 572         service "winbind" force-started
 573
 574         export CTDB_MANAGED_SERVICES="foo winbind bar"
 575
 576         export FAKE_WBINFO_FAIL="no"
 577
 578     else
 579         debug "Marking Winbind service as down and not managed by CTDB"
 580         # Get into known state.
 581         eventscript_call ctdb_service_unmanaged
 582
 583         service "winbind" force-stopped
 584
 585         export CTDB_MANAGED_SERVICES="foo bar"
 586         unset CTDB_MANAGES_WINBIND
 587
 588         export FAKE_WBINFO_FAIL="yes"
 589     fi
 590 }
 591
 592 wbinfo_down ()
 593 {
 594     debug "Making wbinfo commands fail"
 595     FAKE_WBINFO_FAIL="yes"
 596 }
 597
 598 ######################################################################
 599
 600 # NFS fakery
 601
 602 setup_nfs ()
 603 {
 604     setup_ctdb
 605
 606     service_name="nfs"
 607
 608     export FAKE_RPCINFO_SERVICES=""
 609
 610     export CTDB_NFS_SKIP_SHARE_CHECK="no"
 611
 612     export CTDB_MONITOR_NFS_THREAD_COUNT RPCNFSDCOUNT FAKE_NFSD_THREAD_PIDS
 613     export CTDB_NFS_DUMP_STUCK_THREADS
 614
 615     # Reset the failcounts for nfs services.
 616     eventscript_call eval rm -f '$ctdb_fail_dir/nfs_*'
 617
 618     if [ "$1" != "down" ] ; then
 619         debug "Setting up NFS environment: all RPC services up, NFS managed by CTDB"
 620
 621         eventscript_call ctdb_service_managed
 622         service "nfs" force-started  # might not be enough
 623
 624         export CTDB_MANAGED_SERVICES="foo nfs bar"
 625
 626         rpc_services_up "nfs" "mountd" "rquotad" "nlockmgr" "status"
 627     else
 628         debug "Setting up NFS environment: all RPC services down, NFS not managed by CTDB"
 629
 630         eventscript_call ctdb_service_unmanaged
 631         service "nfs" force-stopped  # might not be enough
 632         eventscript_call startstop_nfs stop
 633
 634         export CTDB_MANAGED_SERVICES="foo bar"
 635         unset CTDB_MANAGES_NFS
 636     fi
 637 }
 638
 639 setup_nfs_ganesha ()
 640 {
 641     setup_nfs "$@"
 642     export CTDB_NFS_SERVER_MODE="ganesha"
 643     if [ "$1" != "down" ] ; then
 644         export CTDB_MANAGES_NFS="yes"
 645     fi
 646
 647     # We do not support testing the Ganesha-nfsd-specific part of the
 648     # eventscript.
 649     export CTDB_SKIP_GANESHA_NFSD_CHECK="yes"
 650     export CTDB_NFS_SKIP_SHARE_CHECK="yes"
 651 }
 652
 653 rpc_services_down ()
 654 {
 655     for _i ; do
 656         debug "Marking RPC service \"${_i}\" as unavailable"
 657         FAKE_RPCINFO_SERVICES=$(echo "$FAKE_RPCINFO_SERVICES" | sed -r -e "s@[[:space:]]*${_i}:[0-9]+:[0-9]+@@g")
 658     done
 659 }
 660
 661 rpc_services_up ()
 662 {
 663     for _i ; do
 664         debug "Marking RPC service \"${_i}\" as available"
 665         case "$_i" in
 666             nfs)      _t="2:3" ;;
 667             mountd)   _t="1:3" ;;
 668             rquotad)  _t="1:2" ;;
 669             nlockmgr) _t="3:4" ;;
 670             status)   _t="1:1" ;;
 671             *) die "Internal error - unsupported RPC service \"${_i}\"" ;;
 672         esac
 673
 674         FAKE_RPCINFO_SERVICES="${FAKE_RPCINFO_SERVICES}${FAKE_RPCINFO_SERVICES:+ }${_i}:${_t}"
 675     done
 676 }
 677
 678 # Set the required result for a particular RPC program having failed
 679 # for a certain number of iterations.  This is probably still a work
 680 # in progress.  Note that we could hook aggressively
 681 # nfs_check_rpc_service() to try to implement this but we're better
 682 # off testing nfs_check_rpc_service() using independent code...  even
 683 # if it is incomplete and hacky.  So, if the 60.nfs eventscript
 684 # changes and the tests start to fail then it may be due to this
 685 # function being incomplete.
 686 rpc_set_service_failure_response ()
 687 {
 688     _progname="$1"
 689     # The number of failures defaults to the iteration number.  This
 690     # will be true when we fail from the 1st iteration... but we need
 691     # the flexibility to set the number of failures.
 692     _numfails="${2:-${iteration}}"
 693
 694     _etc="$CTDB_ETCDIR" # shortcut for readability
 695     for _c in "$_etc/sysconfig/nfs" "$_etc/default/nfs" "$_etc/ctdb/sysconfig/nfs" ; do
 696         if [ -r "$_c" ] ; then
 697             . "$_c"
 698             break
 699         fi
 700     done
 701
 702     # A handy newline.  :-)
 703     _nl="
 704 "
 705
 706     # Default
 707     ok_null
 708
 709     _file=$(ls "${CTDB_BASE}/nfs-rpc-checks.d/"[0-9][0-9]."${_progname}.check")
 710     [ -r "$_file" ] || die "RPC check file \"$_file\" does not exist or is not unique"
 711
 712     while read _op _li _actions ; do
 713         # Skip comments
 714         case "$_op" in
 715             \#*) continue ;;
 716         esac
 717
 718         _hit=false
 719         if [ "$_op" != "%" ] ; then
 720             if [ $_numfails $_op $_li ] ; then
 721                 _hit=true
 722             fi
 723         else
 724             if [ $(($_numfails $_op $_li)) -eq 0 ] ; then
 725                 _hit=true
 726             fi
 727         fi
 728         if $_hit ; then
 729             _out=""
 730             _rc=0
 731             for _action in $_actions ; do
 732                 case "$_action" in
 733                     verbose)
 734                         _ver=1
 735                         _pn="$_progname"
 736                         case "$_progname" in
 737                             nfsd) _ver=3 ; _pn="nfs" ;;
 738                             lockd) _ver=4 ; _pn="nlockmgr" ;;
 739                             statd) _pn="status" ;;
 740                         esac
 741                         _out="\
 742 ERROR: $_pn failed RPC check:
 743 rpcinfo: RPC: Program not registered
 744 program $_pn version $_ver is not available"
 745                         ;;
 746                     restart*)
 747                         _p="rpc.${_progname}"
 748                         case "$_action" in
 749                             *:b) _bg="&" ;;
 750                             *)   _bg=""  ;;
 751                         esac
 752                         case "$_progname" in
 753                             nfsd)
 754                                 _t="\
 755 Trying to restart NFS service"
 756
 757                                 if [ -n "$CTDB_NFS_DUMP_STUCK_THREADS" ] ; then
 758                                     for _pid in $FAKE_NFSD_THREAD_PIDS ; do
 759                                         _t="\
 760 $_t
 761 ${_bg}Stack trace for stuck nfsd thread [${_pid}]:
 762 ${_bg}[<ffffffff87654321>] fake_stack_trace_for_pid_${_pid}/stack+0x0/0xff"
 763                                     done
 764                                 fi
 765
 766                                 _t="\
 767 ${_t}
 768 ${_bg}Starting nfslock: OK
 769 ${_bg}Starting nfs: OK"
 770                                 ;;
 771                             lockd)
 772                                 _t="\
 773 Trying to restart lock manager service
 774 ${_bg}Starting nfslock: OK"
 775                                 ;;
 776                             *)
 777                                 _t="Trying to restart $_progname [${_p}]"
 778                         esac
 779                         _out="${_out}${_out:+${_nl}}${_t}"
 780                         ;;
 781                     unhealthy)
 782                         _rc=1
 783                 esac
 784             done
 785             required_result $_rc "$_out"
 786             return
 787         fi
 788     done <"$_file"
 789 }
 790
 791 ######################################################################
 792
 793 # VSFTPD fakery
 794
 795 setup_vsftpd ()
 796 {
 797     service_name="vsftpd"
 798
 799     if [ "$1" != "down" ] ; then
 800         die "setup_vsftpd up not implemented!!!"
 801     else
 802         debug "Setting up VSFTPD environment: service down, not managed by CTDB"
 803
 804         eventscript_call ctdb_service_unmanaged
 805         service vsftpd force-stopped
 806
 807         export CTDB_MANAGED_SERVICES="foo"
 808         unset CTDB_MANAGES_VSFTPD
 809     fi
 810 }
 811
 812 ######################################################################
 813
 814 # HTTPD fakery
 815
 816 setup_httpd ()
 817 {
 818     if [ "$1" != "down" ] ; then
 819         die "setup_httpd up not implemented!!!"
 820     else
 821         debug "Setting up HTTPD environment: service down, not managed by CTDB"
 822
 823         for service_name in "apache2" "httpd" ; do
 824             eventscript_call ctdb_service_unmanaged
 825             service "$service_name" force-stopped
 826         done
 827
 828         export CTDB_MANAGED_SERVICES="foo"
 829         unset CTDB_MANAGES_HTTPD
 830     fi
 831 }
 832
 833 ######################################################################
 834
 835 # multipathd fakery
 836
 837 setup_multipathd ()
 838 {
 839     for i ; do
 840         case "$i" in
 841             \!*)
 842                 _t="${i#!}"
 843                 echo "Marking ${_t} as having no active paths"
 844                 FAKE_MULTIPATH_FAILURES="${FAKE_MULTIPATH_FAILURES}${FAKE_MULTIPATH+FAILURES:+ }${_t}"
 845                 ;;
 846             *)
 847                 _t="$i"
 848         esac
 849         CTDB_MONITOR_MPDEVICES="${CTDB_MONITOR_MPDEVICES}${CTDB_MONITOR_MPDEVICES:+ }${_t}"
 850     done
 851
 852     export CTDB_MONITOR_MPDEVICES FAKE_MULTIPATH_FAILURES
 853     export FAKE_SLEEP_FORCE=0.1
 854 }
 855
 856 ######################################################################
 857
 858 # Result and test functions
 859
 860 # Set some globals and print the summary.
 861 define_test ()
 862 {
 863     desc="$1"
 864
 865     _f=$(basename "$0" ".sh")
 866
 867     # Remaining format should be NN.service.event.NNN or NN.service.NNN:
 868     _num="${_f##*.}"
 869     _f="${_f%.*}"
 870     case "$_f" in
 871         *.*.*)
 872             script="${_f%.*}"
 873             event="${_f##*.}"
 874             ;;
 875         *.*)
 876             script="$_f"
 877             unset event
 878             ;;
 879         *)
 880             die "Internal error - unknown testcase filename format"
 881     esac
 882
 883     printf "%-17s %-10s %-4s - %s\n\n" "$script" "$event" "$_num" "$desc"
 884 }
 885
 886 _extra_header ()
 887 {
 888     cat <<EOF
 889 CTDB_BASE="$CTDB_BASE"
 890 CTDB_ETCDIR="$CTDB_ETCDIR"
 891 ctdb client is "$(which ctdb)"
 892 ip command is "$(which ip)"
 893 EOF
 894 }
 895
 896 # Run an eventscript once.  The test passes if the return code and
 897 # output match those required.
 898
 899 # Any args are passed to the eventscript.
 900
 901 simple_test ()
 902 {
 903     [ -n "$event" ] || die 'simple_test: $event not set'
 904
 905     _extra_header=$(_extra_header)
 906
 907     echo "Running eventscript \"$script $event${1:+ }$*\""
 908     _shell=""
 909     if $TEST_COMMAND_TRACE ; then
 910         _shell="sh -x"
 911     else
 912         _shell="sh"
 913     fi
 914     _out=$($_shell "${CTDB_BASE}/events.d/$script" "$event" "$@" 2>&1)
 915
 916     result_check "$_extra_header"
 917 }
 918
 919 simple_test_event ()
 920 {
 921     # If something has previously failed then don't continue.
 922     : ${_passed:=true}
 923     $_passed || return 1
 924
 925     event="$1" ; shift
 926     echo "=================================================="
 927     simple_test "$@"
 928 }
 929
 930 simple_test_command ()
 931 {
 932     # If something has previously failed then don't continue.
 933     : ${_passed:=true}
 934     $_passed || return 1
 935
 936     echo "=================================================="
 937     echo "Running command \"$*\""
 938     _out=$("$@" 2>&1)
 939
 940     result_check
 941 }
 942
 943 check_ctdb_logfile ()
 944 {
 945     # If something has previously failed then don't continue.
 946     : ${_passed:=true}
 947     $_passed || return 1
 948
 949     echo "=================================================="
 950     echo "Checking CTDB_LOGFILE=\"${CTDB_LOGFILE}\""
 951     _out=$(cat "$CTDB_LOGFILE" 2>&1)
 952
 953     result_check
 954 }
 955
 956 # Run an eventscript iteratively.
 957 # - 1st argument is the number of iterations.
 958 # - 2nd argument is something to eval to do setup for every iteration.
 959 #   The easiest thing to do here is to define a function and pass it
 960 #   here.
 961 # - Subsequent arguments come in pairs: an iteration number and
 962 #   something to eval for that iteration.  Each time an iteration
 963 #   number is matched the associated argument is given to eval after
 964 #   the default setup is done.  The iteration numbers need to be given
 965 #   in ascending order.
 966 #
 967 # Some optional args can be given *before* these, surrounded by extra
 968 # "--" args.  These args are passed to the eventscript.  Quoting is
 969 # lost.
 970 #
 971 # One use of the 2nd and further arguments is to call
 972 # required_result() to change what is expected of a particular
 973 # iteration.
 974 iterate_test ()
 975 {
 976     [ -n "$event" ] || die 'simple_test: $event not set'
 977
 978     args=""
 979     if [ "$1" = "--" ] ; then
 980         shift
 981         while [ "$1" != "--" ] ; do
 982             args="${args}${args:+ }$1"
 983             shift
 984         done
 985         shift
 986     fi
 987
 988     _repeats="$1"
 989     _setup_default="$2"
 990     shift 2
 991
 992     echo "Running $_repeats iterations of \"$script $event\" $args"
 993
 994     _result=true
 995
 996     for iteration in $(seq 1 $_repeats) ; do
 997         # This is inefficient because the iteration-specific setup
 998         # might completely replace the default one.  However, running
 999         # the default is good because it allows you to revert to a
1000         # particular result without needing to specify it explicitly.
1001         eval $_setup_default
1002         if [ $iteration = "$1" ] ; then
1003             eval $2
1004             shift 2
1005         fi
1006
1007         _shell=""
1008         if $TEST_COMMAND_TRACE ; then
1009             _shell="sh -x"
1010         else
1011             _shell="sh"
1012         fi
1013         _out=$($_shell "${CTDB_BASE}/events.d/$script" "$event" $args 2>&1)
1014         _rc=$?
1015
1016         _fout=$(echo "$_out" | result_filter)
1017
1018         if [ "$_fout" = "$required_output" -a $_rc = $required_rc ] ; then
1019             _passed=true
1020         else
1021             _passed=false
1022             _result=false
1023         fi
1024
1025         result_print "$_passed" "$_out" "$_rc" "Iteration $iteration"
1026     done
1027
1028     result_footer "$_result" "$(_extra_header)"
1029 }