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     case "$EVENTSCRIPTS_PATH" in
  13         /*) : ;;
  14         *) EVENTSCRIPTS_PATH="${PWD}/${EVENTSCRIPTS_PATH}" ;;
  15     esac
  16 fi
  17
  18 export EVENTSCRIPTS_PATH
  19
  20 PATH="${EVENTSCRIPTS_PATH}:${PATH}"
  21
  22 export EVENTSCRIPTS_TESTS_VAR_DIR="${TEST_VAR_DIR}/unit_eventscripts"
  23 if [ -d "$EVENTSCRIPTS_TESTS_VAR_DIR" -a \
  24     "$EVENTSCRIPTS_TESTS_VAR_DIR" != "/unit_eventscripts" ] ; then
  25     rm -r "$EVENTSCRIPTS_TESTS_VAR_DIR"
  26 fi
  27 mkdir -p "$EVENTSCRIPTS_TESTS_VAR_DIR"
  28 export CTDB_VARDIR="$EVENTSCRIPTS_TESTS_VAR_DIR/ctdb"
  29
  30 export CTDB_LOGGING="file:${EVENTSCRIPTS_TESTS_VAR_DIR}/log.ctdb"
  31 touch "${CTDB_LOGGING#file:}" || \
  32     die "Unable to setup logging for \"$CTDB_LOGGING\""
  33
  34 if [ -d "${TEST_SUBDIR}/etc" ] ; then
  35     cp -a "${TEST_SUBDIR}/etc" "$EVENTSCRIPTS_TESTS_VAR_DIR"
  36     export CTDB_ETCDIR="${EVENTSCRIPTS_TESTS_VAR_DIR}/etc"
  37 else
  38     die "Unable to setup \$CTDB_ETCDIR"
  39 fi
  40
  41 if [ -d "${TEST_SUBDIR}/etc-ctdb" ] ; then
  42     cp -prL "${TEST_SUBDIR}/etc-ctdb" "$EVENTSCRIPTS_TESTS_VAR_DIR"
  43     export CTDB_BASE="${EVENTSCRIPTS_TESTS_VAR_DIR}/etc-ctdb"
  44 else
  45     die "Unable to set \$CTDB_BASE"
  46 fi
  47 export CTDB_BASE
  48
  49 if [ ! -d "${CTDB_BASE}/events.d" ] ; then
  50     cat <<EOF
  51 ERROR: Directory ${CTDB_BASE}/events.d does not exist.
  52
  53 That means that no eventscripts can be tested.
  54
  55 One possible explanation:
  56
  57   You have CTDB installed via RPMs (or similar), so the regular
  58   CTDB_BASE directory is in /etc/ctdb/
  59
  60   BUT
  61
  62   You have done a regular "configure" and "make install" so the tests
  63   are installed under /usr/local/.
  64
  65 If so, one possible hack to fix this is to create a symlink:
  66
  67   ln -s /etc/ctdb /usr/local/etc/ctdb
  68
  69 This is nasty but it works...  :-)
  70 EOF
  71     exit 1
  72 fi
  73
  74 ######################################################################
  75
  76 if "$TEST_VERBOSE" ; then
  77     debug () { echo "$@" ; }
  78 else
  79     debug () { : ; }
  80 fi
  81
  82 ######################################################################
  83
  84 # General setup fakery
  85
  86 setup_generic ()
  87 {
  88     debug "Setting up shares (3 existing shares)"
  89     # Create 3 fake shares/exports.
  90     export FAKE_SHARES=""
  91     for i in $(seq 1 3) ; do
  92         _s="${EVENTSCRIPTS_TESTS_VAR_DIR}/shares/${i}_existing"
  93         mkdir -p "$_s"
  94         FAKE_SHARES="${FAKE_SHARES}${FAKE_SHARES:+ }${_s}"
  95     done
  96
  97     export FAKE_PROC_NET_BONDING="$EVENTSCRIPTS_TESTS_VAR_DIR/proc-net-bonding"
  98     mkdir -p "$FAKE_PROC_NET_BONDING"
  99     rm -f "$FAKE_PROC_NET_BONDING"/*
 100
 101     export FAKE_ETHTOOL_LINK_DOWN="$EVENTSCRIPTS_TESTS_VAR_DIR/ethtool-link-down"
 102     mkdir -p "$FAKE_ETHTOOL_LINK_DOWN"
 103     rm -f "$FAKE_ETHTOOL_LINK_DOWN"/*
 104
 105     # This can only have 2 levels.  We don't want to resort to usings
 106     # something dangerous like "rm -r" setup time.
 107     export FAKE_IP_STATE="$EVENTSCRIPTS_TESTS_VAR_DIR/fake-ip-state"
 108     mkdir -p "$FAKE_IP_STATE"
 109     rm -f "$FAKE_IP_STATE"/*/*
 110     rm -f "$FAKE_IP_STATE"/* 2>/dev/null || true
 111     rmdir "$FAKE_IP_STATE"/* 2>/dev/null || true
 112
 113
 114     export CTDB_DBDIR="${EVENTSCRIPTS_TESTS_VAR_DIR}/db"
 115     mkdir -p "${CTDB_DBDIR}/persistent"
 116
 117     export FAKE_TDBTOOL_SUPPORTS_CHECK="yes"
 118     export FAKE_TDB_IS_OK
 119     export FAKE_DATE_OUTPUT
 120
 121     export FAKE_NETSTAT_TCP_ESTABLISHED FAKE_TCP_LISTEN FAKE_NETSTAT_UNIX_LISTEN
 122     export FAKE_NETSTAT_TCP_ESTABLISHED_FILE=$(mktemp --tmpdir="$EVENTSCRIPTS_TESTS_VAR_DIR")
 123 }
 124
 125 tcp_port_down ()
 126 {
 127     for _i ; do
 128         debug "Marking TCP port \"${_i}\" as not listening"
 129         FAKE_TCP_LISTEN=$(echo "$FAKE_TCP_LISTEN" | sed -r -e "s@[[:space:]]*[\.0-9]+:${_i}@@g")
 130     done
 131 }
 132
 133 shares_missing ()
 134 {
 135     _fmt="$1" ; shift
 136
 137     # Replace some shares with non-existent ones.
 138     _t=""
 139     _n=1
 140     _nl="
 141 "
 142     export MISSING_SHARES_TEXT=""
 143     for _i in $FAKE_SHARES ; do
 144         if [ $_n = "$1" ] ; then
 145             shift
 146             _i="${_i%_existing}_missing"
 147             debug "Replacing share $_n with missing share \"$_i\""
 148             rmdir "$_i" 2>/dev/null || true
 149             MISSING_SHARES_TEXT="${MISSING_SHARES_TEXT}${MISSING_SHARES_TEXT:+${_nl}}"$(printf "$_fmt" "${_i}")
 150         fi
 151         _t="${_t}${_t:+ }${_i}"
 152         _n=$(($_n + 1))
 153     done
 154     FAKE_SHARES="$_t"
 155 }
 156
 157 # Setup some fake /proc/net/bonding files with just enough info for
 158 # the eventscripts.
 159
 160 # arg1 is interface name, arg2 is currently active slave (use "None"
 161 # if none), arg3 is MII status ("up" or "down").
 162 setup_bond ()
 163 {
 164     _iface="$1"
 165     _slave="${2:-${_iface}_sl_0}"
 166     _mii_s="${3:-up}"
 167     _mii_subs="${4:-${_mii_s:-up}}"
 168     echo "Setting $_iface to be a bond with active slave $_slave and MII status $_mii_s"
 169     cat >"${FAKE_PROC_NET_BONDING}/$_iface" <<EOF
 170 Bonding Mode: IEEE 802.3ad Dynamic link aggregation
 171 Currently Active Slave: $_slave
 172 # Status of the bond
 173 MII Status: $_mii_s
 174 # Status of 1st pretend adapter
 175 MII Status: $_mii_subs
 176 # Status of 2nd pretend adapter
 177 MII Status: $_mii_subs
 178 EOF
 179 }
 180
 181 ethtool_interfaces_down ()
 182 {
 183     for _i ; do
 184         echo "Marking interface $_i DOWN for ethtool"
 185         touch "${FAKE_ETHTOOL_LINK_DOWN}/${_i}"
 186     done
 187 }
 188
 189 ethtool_interfaces_up ()
 190 {
 191     for _i ; do
 192         echo "Marking interface $_i UP for ethtool"
 193         rm -f "${FAKE_ETHTOOL_LINK_DOWN}/${_i}"
 194     done
 195 }
 196
 197 dump_routes ()
 198 {
 199     echo "# ip rule show"
 200     ip rule show
 201
 202     ip rule show |
 203     while read _p _x _i _x _t ; do
 204         # Remove trailing colon after priority/preference.
 205         _p="${_p%:}"
 206         # Only remove rules that match our priority/preference.
 207         [ "$CTDB_PER_IP_ROUTING_RULE_PREF" = "$_p" ] || continue
 208
 209         echo "# ip route show table $_t"
 210         ip route show table "$_t"
 211     done
 212 }
 213
 214 # Copied from 13.per_ip_routing for now... so this is lazy testing  :-(
 215 ipv4_host_addr_to_net ()
 216 {
 217     _host="$1"
 218     _maskbits="$2"
 219
 220     # Convert the host address to an unsigned long by splitting out
 221     # the octets and doing the math.
 222     _host_ul=0
 223     for _o in $(export IFS="." ; echo $_host) ; do
 224         _host_ul=$(( ($_host_ul << 8) + $_o)) # work around Emacs color bug
 225     done
 226
 227     # Calculate the mask and apply it.
 228     _mask_ul=$(( 0xffffffff << (32 - $_maskbits) ))
 229     _net_ul=$(( $_host_ul & $_mask_ul ))
 230
 231     # Now convert to a network address one byte at a time.
 232     _net=""
 233     for _o in $(seq 1 4) ; do
 234         _net="$(($_net_ul & 255))${_net:+.}${_net}"
 235         _net_ul=$(($_net_ul >> 8))
 236     done
 237
 238     echo "${_net}/${_maskbits}"
 239 }
 240
 241 ######################################################################
 242
 243 # CTDB fakery
 244
 245 # Evaluate an expression that probably calls functions or uses
 246 # variables from the CTDB functions file.  This is used for test
 247 # initialisation.
 248 eventscript_call ()
 249 {
 250     (
 251         . "$CTDB_BASE/functions"
 252         "$@"
 253     )
 254 }
 255
 256 # For now this creates the same public addresses each time.  However,
 257 # it could be made more flexible.
 258 setup_public_addresses ()
 259 {
 260     if [ -f "$CTDB_PUBLIC_ADDRESSES" -a \
 261             "${CTDB_PUBLIC_ADDRESSES%/*}" = "$EVENTSCRIPTS_TESTS_VAR_DIR" ] ; then
 262         rm "$CTDB_PUBLIC_ADDRESSES"
 263     fi
 264
 265     export CTDB_PUBLIC_ADDRESSES=$(mktemp \
 266                                        --tmpdir="$EVENTSCRIPTS_TESTS_VAR_DIR" \
 267                                        "public-addresses-XXXXXXXX")
 268
 269     echo "Setting up CTDB_PUBLIC_ADDRESSES=${CTDB_PUBLIC_ADDRESSES}"
 270     cat >"$CTDB_PUBLIC_ADDRESSES" <<EOF
 271 10.0.0.1/24 dev123
 272 10.0.0.2/24 dev123
 273 10.0.0.3/24 dev123
 274 10.0.0.4/24 dev123
 275 10.0.0.5/24 dev123
 276 10.0.0.6/24 dev123
 277 10.0.1.1/24 dev456
 278 10.0.1.2/24 dev456
 279 10.0.1.3/24 dev456
 280 EOF
 281 }
 282
 283 # Need to cope with ctdb_get_pnn().  If a test changes PNN then it
 284 # needs to be using a different state directory, otherwise the wrong
 285 # PNN can already be cached in the state directory.
 286 ctdb_set_pnn ()
 287 {
 288     export FAKE_CTDB_PNN="$1"
 289     echo "Setting up PNN ${FAKE_CTDB_PNN}"
 290
 291     export CTDB_VARDIR="$EVENTSCRIPTS_TESTS_VAR_DIR/ctdb/${FAKE_CTDB_PNN}"
 292     mkdir -p "$CTDB_VARDIR"
 293 }
 294
 295 setup_ctdb ()
 296 {
 297     setup_generic
 298
 299     export FAKE_CTDB_NUMNODES="${1:-3}"
 300     echo "Setting up CTDB with ${FAKE_CTDB_NUMNODES} fake nodes"
 301
 302     ctdb_set_pnn "${2:-0}"
 303
 304     setup_public_addresses
 305
 306     export FAKE_CTDB_STATE="$EVENTSCRIPTS_TESTS_VAR_DIR/fake-ctdb"
 307
 308     export FAKE_CTDB_EXTRA_CONFIG="$EVENTSCRIPTS_TESTS_VAR_DIR/fake-config.sh"
 309     rm -f "$FAKE_CTDB_EXTRA_CONFIG"
 310
 311     export FAKE_CTDB_IFACES_DOWN="$FAKE_CTDB_STATE/ifaces-down"
 312     mkdir -p "$FAKE_CTDB_IFACES_DOWN"
 313     rm -f "$FAKE_CTDB_IFACES_DOWN"/*
 314
 315     export FAKE_CTDB_SCRIPTSTATUS="$FAKE_CTDB_STATE/scriptstatus"
 316     mkdir -p "$FAKE_CTDB_SCRIPTSTATUS"
 317     rm -f "$FAKE_CTDB_SCRIPTSTATUS"/*
 318
 319     export CTDB_PARTIALLY_ONLINE_INTERFACES
 320
 321     export FAKE_CTDB_TUNABLES_OK="MonitorInterval TDBMutexEnabled DatabaseHashSize"
 322     export FAKE_CTDB_TUNABLES_OBSOLETE="EventScriptUnhealthyOnTimeout"
 323 }
 324
 325 setup_config ()
 326 {
 327     cat >"$FAKE_CTDB_EXTRA_CONFIG"
 328 }
 329
 330 setup_memcheck ()
 331 {
 332     setup_ctdb
 333
 334     _swap_total="5857276"
 335
 336     if [ "$1" = "bad" ] ; then
 337         _swap_free="   4352"
 338         _mem_cached=" 112"
 339         _mem_free=" 468"
 340     else
 341         _swap_free="$_swap_total"
 342         _mem_cached="1112"
 343         _mem_free="1468"
 344     fi
 345
 346     export FAKE_PROC_MEMINFO="\
 347 MemTotal:        3940712 kB
 348 MemFree:          225268 kB
 349 Buffers:          146120 kB
 350 Cached:          1139348 kB
 351 SwapCached:        56016 kB
 352 Active:          2422104 kB
 353 Inactive:        1019928 kB
 354 Active(anon):    1917580 kB
 355 Inactive(anon):   523080 kB
 356 Active(file):     504524 kB
 357 Inactive(file):   496848 kB
 358 Unevictable:        4844 kB
 359 Mlocked:            4844 kB
 360 SwapTotal:       ${_swap_total} kB
 361 SwapFree:        ${_swap_free} kB
 362 ..."
 363
 364     export FAKE_FREE_M="\
 365              total       used       free     shared    buffers     cached
 366 Mem:          3848       3634        213          0        142       ${_mem_cached}
 367 -/+ buffers/cache:       2379       ${_mem_free}
 368 Swap:         5719        246       5473"
 369
 370     export CTDB_MONITOR_FREE_MEMORY
 371     export CTDB_MONITOR_FREE_MEMORY_WARN
 372     export CTDB_CHECK_SWAP_IS_NOT_USED
 373 }
 374
 375 ctdb_get_interfaces ()
 376 {
 377     # The echo/subshell forces all the output onto 1 line.
 378     echo $(ctdb ifaces -X | awk -F'|' 'FNR > 1 {print $2}')
 379 }
 380
 381 ctdb_get_1_interface ()
 382 {
 383     _t=$(ctdb_get_interfaces)
 384     echo ${_t%% *}
 385 }
 386
 387 # Print all public addresses as: interface IP maskbits
 388 # Each line is suitable for passing to takeip/releaseip
 389 ctdb_get_all_public_addresses ()
 390 {
 391     _f="${CTDB_PUBLIC_ADDRESSES:-${CTDB_BASE}/public_addresses}"
 392     while IFS="/$IFS" read _ip _maskbits _ifaces ; do
 393         echo "$_ifaces $_ip $_maskbits"
 394     done <"$_f"
 395 }
 396
 397 # Print public addresses on this node as: interface IP maskbits
 398 # Each line is suitable for passing to takeip/releaseip
 399 ctdb_get_my_public_addresses ()
 400 {
 401     ctdb ip -v -X | {
 402         read _x # skip header line
 403
 404         while IFS="|" read _x _ip _x _iface _x ; do
 405             [ -n "$_iface" ] || continue
 406             while IFS="/$IFS" read _i _maskbits _x ; do
 407                 if [ "$_ip" = "$_i" ] ; then
 408                     echo $_iface $_ip $_maskbits
 409                     break
 410                 fi
 411             done <"${CTDB_PUBLIC_ADDRESSES:-${CTDB_BASE}/public_addresses}"
 412         done
 413     }
 414 }
 415
 416 # Prints the 1st public address as: interface IP maskbits
 417 # This is suitable for passing to takeip/releaseip
 418 ctdb_get_1_public_address ()
 419 {
 420     ctdb_get_my_public_addresses | { head -n 1 ; cat >/dev/null ; }
 421 }
 422
 423 ctdb_not_implemented ()
 424 {
 425     export CTDB_NOT_IMPLEMENTED="$1"
 426     ctdb_not_implemented="\
 427 DEBUG: ctdb: command \"$1\" not implemented in stub"
 428 }
 429
 430 ctdb_fake_scriptstatus ()
 431 {
 432     _code="$1"
 433     _status="$2"
 434     _err_out="$3"
 435
 436     _d1=$(date '+%s.%N')
 437     _d2=$(date '+%s.%N')
 438
 439     echo "$_code $_status $_err_out" >"$FAKE_CTDB_SCRIPTSTATUS/$script"
 440 }
 441
 442 ######################################################################
 443
 444 setup_ctdb_policy_routing ()
 445 {
 446     service_name="per_ip_routing"
 447
 448     export CTDB_PER_IP_ROUTING_CONF="$CTDB_BASE/policy_routing"
 449     export CTDB_PER_IP_ROUTING_RULE_PREF=100
 450     export CTDB_PER_IP_ROUTING_TABLE_ID_LOW=1000
 451     export CTDB_PER_IP_ROUTING_TABLE_ID_HIGH=2000
 452
 453     # Tests need to create and populate this file
 454     rm -f "$CTDB_PER_IP_ROUTING_CONF"
 455 }
 456
 457 # Create policy routing configuration in $CTDB_PER_IP_ROUTING_CONF.
 458 # $1 is the number of assigned IPs to use (<num>, all), defaulting to
 459 # 1.  If $2 is "default" then a default route is also added.
 460 create_policy_routing_config ()
 461 {
 462     _num_ips="${1:-1}"
 463     _should_add_default="$2"
 464
 465     ctdb_get_my_public_addresses |
 466     if [ "$_num_ips" = "all" ] ; then
 467         cat
 468     else
 469         { head -n "$_num_ips" ; cat >/dev/null ; }
 470     fi |
 471     while read _dev _ip _bits ; do
 472         _net=$(ipv4_host_addr_to_net "$_ip" "$_bits")
 473         _gw="${_net%.*}.1" # a dumb, calculated default
 474
 475         echo "$_ip $_net"
 476
 477         if [ "$_should_add_default" = "default" ] ; then
 478             echo "$_ip 0.0.0.0/0 $_gw"
 479         fi
 480     done >"$CTDB_PER_IP_ROUTING_CONF"
 481 }
 482
 483 # Check the routes against those that are expected.  $1 is the number
 484 # of assigned IPs to use (<num>, all), defaulting to 1.  If $2 is
 485 # "default" then expect default routes to have been added.
 486 check_routes ()
 487 {
 488     _num_ips="${1:-1}"
 489     _should_add_default="$2"
 490
 491     _policy_rules=""
 492     _policy_routes=""
 493
 494     ctdb_get_my_public_addresses |
 495     if [ "$_num_ips" = "all" ] ; then
 496         cat
 497     else
 498         { head -n "$_num_ips" ; cat >/dev/null ; }
 499     fi | {
 500         while read _dev _ip _bits ; do
 501             _net=$(ipv4_host_addr_to_net "$_ip" "$_bits")
 502             _gw="${_net%.*}.1" # a dumb, calculated default
 503
 504             _policy_rules="${_policy_rules}
 505 ${CTDB_PER_IP_ROUTING_RULE_PREF}:       from $_ip lookup ctdb.$_ip "
 506             _policy_routes="${_policy_routes}
 507 # ip route show table ctdb.$_ip
 508 $_net dev $_dev  scope link "
 509
 510             if [ "$_should_add_default" = "default" ] ; then
 511                 _policy_routes="${_policy_routes}
 512 default via $_gw dev $_dev "
 513             fi
 514         done
 515
 516         ok <<EOF
 517 # ip rule show
 518 0:      from all lookup local ${_policy_rules}
 519 32766:  from all lookup main
 520 32767:  from all lookup default ${_policy_routes}
 521 EOF
 522
 523         simple_test_command dump_routes
 524     } || test_fail
 525 }
 526
 527 ######################################################################
 528
 529 ctdb_catdb_format_pairs ()
 530 {
 531     _count=0
 532
 533     while read _k _v ; do
 534         _kn=$(echo -n "$_k" | wc -c)
 535         _vn=$(echo -n "$_v" | wc -c)
 536         cat <<EOF
 537 key(${_kn}) = "${_k}"
 538 dmaster: 0
 539 rsn: 1
 540 data(${_vn}) = "${_v}"
 541
 542 EOF
 543         _count=$(($_count + 1))
 544     done
 545
 546     echo "Dumped ${_count} records"
 547 }
 548
 549 check_ctdb_tdb_statd_state ()
 550 {
 551     ctdb_get_my_public_addresses |
 552     while read _x _sip _x ; do
 553         for _cip ; do
 554             echo "statd-state@${_sip}@${_cip}" "$FAKE_DATE_OUTPUT"
 555         done
 556     done |
 557     ctdb_catdb_format_pairs | {
 558         ok
 559         simple_test_command ctdb catdb ctdb.tdb
 560     } || test_fail
 561 }
 562
 563 check_statd_callout_smnotify ()
 564 {
 565     _state_even=$(( $(date '+%s') / 2 * 2))
 566     _state_odd=$(($_state_even + 1))
 567
 568     nfs_load_config
 569
 570     ctdb_get_my_public_addresses |
 571     while read _x _sip _x ; do
 572         for _cip ; do
 573             cat <<EOF
 574 --client=${_cip} --ip=${_sip} --server=${_sip} --stateval=${_state_even}
 575 --client=${_cip} --ip=${_sip} --server=${NFS_HOSTNAME} --stateval=${_state_even}
 576 --client=${_cip} --ip=${_sip} --server=${_sip} --stateval=${_state_odd}
 577 --client=${_cip} --ip=${_sip} --server=${NFS_HOSTNAME} --stateval=${_state_odd}
 578 EOF
 579         done
 580     done | {
 581         ok
 582         simple_test_event "notify"
 583     } || test_fail
 584 }
 585
 586 ######################################################################
 587
 588 setup_ctdb_natgw ()
 589 {
 590     debug "Setting up NAT gateway"
 591
 592     natgw_config_dir="${TEST_VAR_DIR}/natgw_config"
 593     mkdir -p "$natgw_config_dir"
 594
 595     # These will accumulate, 1 per test... but will be cleaned up at
 596     # the end.
 597     export CTDB_NATGW_NODES=$(mktemp --tmpdir="$natgw_config_dir")
 598
 599     # Read from stdin
 600     while read _ip _master _dev ; do
 601         echo "$_ip"
 602         if [ "$_master" = "master" ] ; then
 603             export FAKE_CTDB_NATGW_MASTER="$_ip"
 604         fi
 605     done >"$CTDB_NATGW_NODES"
 606
 607     # Assume all of the nodes are on a /24 network and have IPv4
 608     # addresses:
 609     read _ip <"$CTDB_NATGW_NODES"
 610     export CTDB_NATGW_PRIVATE_NETWORK="${_ip%.*}.0/24"
 611
 612     # These are fixed.  Probably don't use the same network for the
 613     # private node IPs.  To unset the default gateway just set it to
 614     # "".  :-)
 615     export CTDB_NATGW_PUBLIC_IP="10.1.1.121/24"
 616     export CTDB_NATGW_PUBLIC_IFACE="eth1"
 617     export CTDB_NATGW_DEFAULT_GATEWAY="10.1.1.254"
 618     export CTDB_NATGW_SLAVE_ONLY=""
 619 }
 620
 621 ok_natgw_master_ip_addr_show ()
 622 {
 623     _mac=$(echo "$CTDB_NATGW_PUBLIC_IFACE" | md5sum | sed -r -e 's@(..)(..)(..)(..)(..)(..).*@\1:\2:\3:\4:\5:\6@')
 624
 625     # This is based on CTDB_NATGW_PUBLIC_IP
 626     _brd="10.1.1.255"
 627
 628 ok <<EOF
 629 1: ${CTDB_NATGW_PUBLIC_IFACE}: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
 630     link/ether ${_mac} brd ff:ff:ff:ff:ff:ff
 631     inet ${CTDB_NATGW_PUBLIC_IP} brd ${_brd} scope global ${CTDB_NATGW_PUBLIC_IFACE}
 632        valid_lft forever preferred_lft forever
 633 EOF
 634 }
 635
 636 ok_natgw_slave_ip_addr_show ()
 637 {
 638     _mac=$(echo "$CTDB_NATGW_PUBLIC_IFACE" | md5sum | sed -r -e 's@(..)(..)(..)(..)(..)(..).*@\1:\2:\3:\4:\5:\6@')
 639 ok <<EOF
 640 1: ${CTDB_NATGW_PUBLIC_IFACE}: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
 641     link/ether ${_mac} brd ff:ff:ff:ff:ff:ff
 642 EOF
 643 }
 644
 645 ok_natgw_master_static_routes ()
 646 {
 647     _nl="
 648 "
 649     _t=""
 650     for _i in $CTDB_NATGW_STATIC_ROUTES ; do
 651         # This is intentionally different to the code in 11.natgw ;-)
 652         case "$_i" in
 653             *@*)
 654                 _net=$(echo "$_i" | sed -e 's|@.*||')
 655                 _gw=$(echo "$_i" | sed -e 's|.*@||')
 656                 ;;
 657             *)
 658                 _net="$_i"
 659                 _gw="$CTDB_NATGW_DEFAULT_GATEWAY"
 660         esac
 661
 662         [ -n "$_gw" ] || continue
 663         _t="${_t}${_t:+${_nl}}"
 664         _t="${_t}${_net} via ${_gw} dev ethXXX  metric 10 "
 665     done
 666     _t=$(echo "$_t" | sort)
 667     ok "$_t"
 668 }
 669
 670 ok_natgw_slave_static_routes ()
 671 {
 672     _nl="
 673 "
 674     _t=""
 675     for _i in $CTDB_NATGW_STATIC_ROUTES ; do
 676         # This is intentionally different to the code in 11.natgw ;-)
 677         _net=$(echo "$_i" | sed -e 's|@.*||')
 678
 679         # The interface for the private network isn't specified as
 680         # part of the NATGW configuration and isn't part of the
 681         # command to add the route.  It is implicitly added by "ip
 682         # route" but our stub doesn't do this and adds "ethXXX".
 683         _t="${_t}${_t:+${_nl}}"
 684         _t="${_t}${_net} via ${FAKE_CTDB_NATGW_MASTER} dev ethXXX  metric 10 "
 685     done
 686     _t=$(echo "$_t" | sort)
 687     ok "$_t"
 688 }
 689
 690 ######################################################################
 691
 692 # Samba/winbind fakery
 693
 694 setup_samba ()
 695 {
 696     setup_ctdb
 697
 698     service_name="samba"
 699
 700     if [ "$1" != "down" ] ; then
 701
 702         debug "Marking Samba services as up, listening and managed by CTDB"
 703         # Get into known state.
 704         eventscript_call ctdb_service_managed
 705
 706         # All possible service names for all known distros.
 707         for i in "smb" "nmb" "samba" ; do
 708             service "$i" force-started
 709         done
 710
 711         export CTDB_SAMBA_SKIP_SHARE_CHECK="no"
 712         export CTDB_MANAGED_SERVICES="foo samba bar"
 713
 714         export FAKE_TCP_LISTEN="0.0.0.0:445 0.0.0.0:139"
 715         export FAKE_WBINFO_FAIL="no"
 716
 717         # Some things in 50.samba are backgrounded and waited for.  If
 718         # we don't sleep at all then timeouts can happen.  This avoids
 719         # that...  :-)
 720         export FAKE_SLEEP_FORCE=0.1
 721     else
 722         debug "Marking Samba services as down, not listening and not managed by CTDB"
 723         # Get into known state.
 724         eventscript_call ctdb_service_unmanaged
 725
 726         # All possible service names for all known distros.
 727         for i in "smb" "nmb" "samba" ; do
 728             service "$i" force-stopped
 729         done
 730
 731         export CTDB_SAMBA_SKIP_SHARE_CHECK="no"
 732         export CTDB_MANAGED_SERVICES="foo bar"
 733         unset CTDB_MANAGES_SAMBA
 734
 735         export FAKE_TCP_LISTEN=""
 736         export FAKE_WBINFO_FAIL="yes"
 737     fi
 738 }
 739
 740 setup_winbind ()
 741 {
 742     setup_ctdb
 743
 744     service_name="winbind"
 745
 746     if [ "$1" != "down" ] ; then
 747
 748         debug "Marking Winbind service as up and managed by CTDB"
 749         # Get into known state.
 750         eventscript_call ctdb_service_managed
 751
 752         service "winbind" force-started
 753
 754         export CTDB_MANAGED_SERVICES="foo winbind bar"
 755
 756         export FAKE_WBINFO_FAIL="no"
 757
 758     else
 759         debug "Marking Winbind service as down and not managed by CTDB"
 760         # Get into known state.
 761         eventscript_call ctdb_service_unmanaged
 762
 763         service "winbind" force-stopped
 764
 765         export CTDB_MANAGED_SERVICES="foo bar"
 766         unset CTDB_MANAGES_WINBIND
 767
 768         export FAKE_WBINFO_FAIL="yes"
 769     fi
 770 }
 771
 772 wbinfo_down ()
 773 {
 774     debug "Making wbinfo commands fail"
 775     FAKE_WBINFO_FAIL="yes"
 776 }
 777
 778 ######################################################################
 779
 780 # NFS fakery
 781
 782 setup_nfs ()
 783 {
 784     setup_ctdb
 785
 786     service_name="nfs"
 787
 788     export FAKE_RPCINFO_SERVICES=""
 789
 790     export CTDB_NFS_SKIP_SHARE_CHECK="no"
 791
 792     export RPCNFSDCOUNT
 793     export CTDB_NFS_DUMP_STUCK_THREADS
 794
 795     # Reset the failcounts for nfs services.
 796     eventscript_call eval rm -f '$ctdb_fail_dir/nfs_*'
 797
 798     if [ "$1" != "down" ] ; then
 799         debug "Setting up NFS environment: all RPC services up, NFS managed by CTDB"
 800
 801         eventscript_call ctdb_service_managed
 802         service "nfs" force-started
 803         service "nfslock" force-started
 804
 805         export CTDB_MANAGED_SERVICES="foo nfs bar"
 806
 807         rpc_services_up "nfs" "mountd" "rquotad" "nlockmgr" "status"
 808
 809         nfs_setup_fake_threads "nfsd"
 810         nfs_setup_fake_threads "rpc.foobar"  # Just set the variable to empty
 811     else
 812         debug "Setting up NFS environment: all RPC services down, NFS not managed by CTDB"
 813
 814         eventscript_call ctdb_service_unmanaged
 815         service "nfs" force-stopped
 816         service "nfslock" force-stopped
 817
 818         export CTDB_MANAGED_SERVICES="foo bar"
 819         unset CTDB_MANAGES_NFS
 820     fi
 821
 822     # This is really nasty.  However, when we test NFS we don't
 823     # actually test statd-callout. If we leave it there then left
 824     # over, backgrounded instances of statd-callout will do horrible
 825     # things with the "ctdb ip" stub and cause the actual
 826     # statd-callout tests that follow to fail.
 827     rm "${CTDB_BASE}/statd-callout"
 828 }
 829
 830 setup_nfs_ganesha ()
 831 {
 832     setup_nfs "$@"
 833     export CTDB_NFS_CALLOUT="${CTDB_BASE}/nfs-ganesha-callout"
 834     if [ "$1" != "down" ] ; then
 835         export CTDB_MANAGES_NFS="yes"
 836     fi
 837
 838     export CTDB_NFS_SKIP_SHARE_CHECK="yes"
 839 }
 840
 841 rpc_services_down ()
 842 {
 843     for _i ; do
 844         debug "Marking RPC service \"${_i}\" as unavailable"
 845         FAKE_RPCINFO_SERVICES=$(echo "$FAKE_RPCINFO_SERVICES" | sed -r -e "s@[[:space:]]*${_i}:[0-9]+:[0-9]+@@g")
 846     done
 847 }
 848
 849 rpc_services_up ()
 850 {
 851     for _i ; do
 852         debug "Marking RPC service \"${_i}\" as available"
 853         case "$_i" in
 854             nfs)      _t="2:3" ;;
 855             mountd)   _t="1:3" ;;
 856             rquotad)  _t="1:2" ;;
 857             nlockmgr) _t="3:4" ;;
 858             status)   _t="1:1" ;;
 859             *) die "Internal error - unsupported RPC service \"${_i}\"" ;;
 860         esac
 861
 862         FAKE_RPCINFO_SERVICES="${FAKE_RPCINFO_SERVICES}${FAKE_RPCINFO_SERVICES:+ }${_i}:${_t}"
 863     done
 864 }
 865
 866
 867 nfs_load_config ()
 868 {
 869     _etc="$CTDB_ETCDIR" # shortcut for readability
 870     for _c in "$_etc/sysconfig/nfs" "$_etc/default/nfs" "$_etc/ctdb/sysconfig/nfs" ; do
 871         if [ -r "$_c" ] ; then
 872             . "$_c"
 873             break
 874         fi
 875     done
 876 }
 877
 878 nfs_setup_fake_threads ()
 879 {
 880     _prog="$1" ; shift
 881
 882     case "$_prog" in
 883         nfsd)
 884             export PROCFS_PATH=$(mktemp -d --tmpdir="$EVENTSCRIPTS_TESTS_VAR_DIR")
 885             _threads="${PROCFS_PATH}/fs/nfsd/threads"
 886             mkdir -p $(dirname "$_threads")
 887             echo $# >"$_threads"
 888             export FAKE_NFSD_THREAD_PIDS="$*"
 889             ;;
 890         *)
 891             export FAKE_RPC_THREAD_PIDS="$*"
 892             ;;
 893     esac
 894 }
 895
 896 program_stack_traces ()
 897 {
 898     _prog="$1"
 899     _max="${2:-1}"
 900
 901     _count=1
 902     for _pid in ${FAKE_NFSD_THREAD_PIDS:-$FAKE_RPC_THREAD_PIDS} ; do
 903         [ $_count -le $_max ] || break
 904
 905         cat <<EOF
 906 Stack trace for ${_prog}[${_pid}]:
 907 [<ffffffff87654321>] fake_stack_trace_for_pid_${_pid}/stack+0x0/0xff
 908 EOF
 909         _count=$(($_count + 1))
 910     done
 911 }
 912
 913 guess_output ()
 914 {
 915     case "$1" in
 916         $CTDB_NFS_CALLOUT\ start\ nlockmgr)
 917             echo "&Starting nfslock: OK"
 918             ;;
 919         $CTDB_NFS_CALLOUT\ start\ nfs)
 920             cat <<EOF
 921 &Starting nfslock: OK
 922 &Starting nfs: OK
 923 EOF
 924             ;;
 925         *)
 926             : # Nothing
 927     esac
 928 }
 929
 930 # Set the required result for a particular RPC program having failed
 931 # for a certain number of iterations.  This is probably still a work
 932 # in progress.  Note that we could hook aggressively
 933 # nfs_check_rpc_service() to try to implement this but we're better
 934 # off testing nfs_check_rpc_service() using independent code...  even
 935 # if it is incomplete and hacky.  So, if the 60.nfs eventscript
 936 # changes and the tests start to fail then it may be due to this
 937 # function being incomplete.
 938 rpc_set_service_failure_response ()
 939 {
 940     _rpc_service="$1"
 941     _numfails="${2:-1}" # default 1
 942
 943     # Default
 944     ok_null
 945     if [ $_numfails -eq 0 ] ; then
 946         return
 947     fi
 948
 949     nfs_load_config
 950
 951     # A handy newline.  :-)
 952     _nl="
 953 "
 954
 955     _dir="${CTDB_NFS_CHECKS_DIR:-${CTDB_BASE}/nfs-checks.d}"
 956
 957     _file=$(ls "$_dir"/[0-9][0-9]."${_rpc_service}.check")
 958     [ -r "$_file" ] || die "RPC check file \"$_file\" does not exist or is not unique"
 959
 960     _out=$(mktemp --tmpdir="$EVENTSCRIPTS_TESTS_VAR_DIR")
 961     _rc_file=$(mktemp --tmpdir="$EVENTSCRIPTS_TESTS_VAR_DIR")
 962
 963     (
 964         # Subshell to restrict scope variables...
 965
 966         # Defaults
 967         family="tcp"
 968         version=""
 969         unhealthy_after=1
 970         restart_every=0
 971         service_stop_cmd=""
 972         service_start_cmd=""
 973         service_check_cmd=""
 974         service_debug_cmd=""
 975
 976         # Don't bother syntax checking, eventscript does that...
 977         . "$_file"
 978
 979         # Just use the first version, default to 1.  This is dumb but
 980         # handles all the cases that we care about now...
 981         if [ -n "$version" ] ; then
 982             _ver="${version%% *}"
 983         else
 984             _ver=1
 985         fi
 986         _rpc_check_out="\
 987 $_rpc_service failed RPC check:
 988 rpcinfo: RPC: Program not registered
 989 program $_rpc_service version $_ver is not available"
 990
 991         if [ $unhealthy_after -gt 0 -a $_numfails -ge $unhealthy_after ] ; then
 992             _unhealthy=true
 993             echo 1 >"$_rc_file"
 994             echo "ERROR: ${_rpc_check_out}" >>"$_out"
 995         else
 996             _unhealthy=false
 997             echo 0 >"$_rc_file"
 998         fi
 999
1000         if [ $restart_every -gt 0 -a $(($_numfails % $restart_every)) -eq 0 ] ; then
1001             if ! $_unhealthy ; then
1002                 echo "WARNING: ${_rpc_check_out}" >>"$_out"
1003             fi
1004
1005             echo "Trying to restart service \"${_rpc_service}\"..." >>"$_out"
1006
1007             if [ -n "$service_debug_cmd" ] ; then
1008                 $service_debug_cmd 2>&1 >>"$_out"
1009             fi
1010
1011             guess_output "$service_start_cmd" >>"$_out"
1012         fi
1013     )
1014
1015     read _rc <"$_rc_file"
1016     required_result $_rc <"$_out"
1017
1018     rm -f "$_out" "$_rc_file"
1019 }
1020
1021 ######################################################################
1022
1023 # VSFTPD fakery
1024
1025 setup_vsftpd ()
1026 {
1027     service_name="vsftpd"
1028
1029     if [ "$1" != "down" ] ; then
1030         die "setup_vsftpd up not implemented!!!"
1031     else
1032         debug "Setting up VSFTPD environment: service down, not managed by CTDB"
1033
1034         eventscript_call ctdb_service_unmanaged
1035         service vsftpd force-stopped
1036
1037         export CTDB_MANAGED_SERVICES="foo"
1038         unset CTDB_MANAGES_VSFTPD
1039     fi
1040 }
1041
1042 ######################################################################
1043
1044 # HTTPD fakery
1045
1046 setup_httpd ()
1047 {
1048     if [ "$1" != "down" ] ; then
1049         die "setup_httpd up not implemented!!!"
1050     else
1051         debug "Setting up HTTPD environment: service down, not managed by CTDB"
1052
1053         for service_name in "apache2" "httpd" ; do
1054             eventscript_call ctdb_service_unmanaged
1055             service "$service_name" force-stopped
1056         done
1057
1058         export CTDB_MANAGED_SERVICES="foo"
1059         unset CTDB_MANAGES_HTTPD
1060     fi
1061 }
1062
1063 ######################################################################
1064
1065 # multipathd fakery
1066
1067 setup_multipathd ()
1068 {
1069     for i ; do
1070         case "$i" in
1071             \!*)
1072                 _t="${i#!}"
1073                 echo "Marking ${_t} as having no active paths"
1074                 FAKE_MULTIPATH_FAILURES="${FAKE_MULTIPATH_FAILURES}${FAKE_MULTIPATH+FAILURES:+ }${_t}"
1075                 ;;
1076             *)
1077                 _t="$i"
1078         esac
1079         CTDB_MONITOR_MPDEVICES="${CTDB_MONITOR_MPDEVICES}${CTDB_MONITOR_MPDEVICES:+ }${_t}"
1080     done
1081
1082     export CTDB_MONITOR_MPDEVICES FAKE_MULTIPATH_FAILURES
1083     export FAKE_SLEEP_FORCE=0.1
1084 }
1085
1086 ######################################################################
1087
1088 # Result and test functions
1089
1090 # Set some globals and print the summary.
1091 define_test ()
1092 {
1093     desc="$1"
1094
1095     _f=$(basename "$0" ".sh")
1096
1097     # Remaining format should be NN.service.event.NNN or NN.service.NNN:
1098     _num="${_f##*.}"
1099     _f="${_f%.*}"
1100
1101     case "$_f" in
1102         [0-9][0-9].*.*)
1103             script="${_f%.*}"
1104             event="${_f##*.}"
1105             script_dir="${CTDB_BASE}/events.d"
1106             ;;
1107         [0-9][0-9].*)
1108             script="$_f"
1109             unset event
1110             script_dir="${CTDB_BASE}/events.d"
1111             ;;
1112         *.*)
1113             script="${_f%.*}"
1114             event="${_f##*.}"
1115             script_dir="${CTDB_BASE}"
1116             ;;
1117         *)
1118             script="${_f%.*}"
1119             unset event
1120             script_dir="${CTDB_BASE}"
1121     esac
1122
1123     [ -r "${script_dir}/${script}" ] || \
1124         die "Internal error - unable to find script \"${script_dir}/${script}\""
1125
1126     printf "%-17s %-10s %-4s - %s\n\n" "$script" "$event" "$_num" "$desc"
1127 }
1128
1129 # Run an eventscript once.  The test passes if the return code and
1130 # output match those required.
1131
1132 # Any args are passed to the eventscript.
1133
1134 simple_test ()
1135 {
1136     [ -n "$event" ] || die 'simple_test: $event not set'
1137
1138     args="$@"
1139
1140     test_header ()
1141     {
1142         echo "Running script \"$script $event${args:+ }$args\""
1143     }
1144
1145     extra_header ()
1146     {
1147         cat <<EOF
1148
1149 ##################################################
1150 CTDB_BASE="$CTDB_BASE"
1151 CTDB_ETCDIR="$CTDB_ETCDIR"
1152 ctdb client is "$(which ctdb)"
1153 ip command is "$(which ip)"
1154 EOF
1155     }
1156
1157     script_test "${script_dir}/${script}" "$event" "$@"
1158
1159     reset_test_header
1160     reset_extra_header
1161 }
1162
1163 simple_test_event ()
1164 {
1165     # If something has previously failed then don't continue.
1166     : ${_passed:=true}
1167     $_passed || return 1
1168
1169     event="$1" ; shift
1170     echo "=================================================="
1171     simple_test "$@"
1172 }
1173
1174 simple_test_command ()
1175 {
1176     unit_test "$@"
1177 }
1178
1179 # Run an NFS eventscript iteratively.
1180 #
1181 # - 1st argument is the number of iterations.
1182 #
1183 # - 2nd argument is the NFS/RPC service being tested
1184 #
1185 #   rpcinfo (or $service_check_cmd) is used on each iteration to test
1186 #   the availability of the service
1187 #
1188 #   If this is not set or null then no RPC service is checked and the
1189 #   required output is not reset on each iteration.  This is useful in
1190 #   baseline tests to confirm that the eventscript and test
1191 #   infrastructure is working correctly.
1192 #
1193 # - Subsequent arguments come in pairs: an iteration number and
1194 #   something to eval before that iteration.  Each time an iteration
1195 #   number is matched the associated argument is given to eval after
1196 #   the default setup is done.  The iteration numbers need to be given
1197 #   in ascending order.
1198 #
1199 #   These arguments can allow a service to be started or stopped
1200 #   before a particular iteration.
1201 #
1202 nfs_iterate_test ()
1203 {
1204     _repeats="$1"
1205     _rpc_service="$2"
1206     if [ -n "$2" ] ; then
1207         shift 2
1208     else
1209         shift
1210     fi
1211
1212     echo "Running $_repeats iterations of \"$script $event\" $args"
1213
1214     _iterate_failcount=0
1215     for _iteration in $(seq 1 $_repeats) ; do
1216         # This is not a numerical comparison because $1 will often not
1217         # be set.
1218         if [ "$_iteration" = "$1" ] ; then
1219             debug "##################################################"
1220             eval "$2"
1221             debug "##################################################"
1222             shift 2
1223         fi
1224         if [ -n "$_rpc_service" ] ; then
1225             _ok=false
1226             if [ -n "$service_check_cmd" ] ; then
1227                 if eval "$service_check_cmd" ; then
1228                     _ok=true
1229                 fi
1230             else
1231                 if rpcinfo -T tcp localhost "$_rpc_service" >/dev/null 2>&1 ; then
1232                     _ok=true
1233                 fi
1234             fi
1235
1236             if $_ok ; then
1237                 _iterate_failcount=0
1238             else
1239                 _iterate_failcount=$(($_iterate_failcount + 1))
1240             fi
1241             rpc_set_service_failure_response "$_rpc_service" $_iterate_failcount
1242         fi
1243         _out=$(simple_test 2>&1)
1244         _ret=$?
1245         if "$TEST_VERBOSE" || [ $_ret -ne 0 ] ; then
1246             echo "##################################################"
1247             echo "Iteration ${_iteration}:"
1248             echo "$_out"
1249         fi
1250         if [ $_ret -ne 0 ] ; then
1251             exit $_ret
1252         fi
1253     done
1254 }