ctdb-tests: Update integration tests to use ctdb -X
[vlendec/samba-autobuild/.git] / ctdb / tests / scripts / integration.bash
1 # Hey Emacs, this is a -*- shell-script -*- !!!  :-)
2
3 . "${TEST_SCRIPTS_DIR}/common.sh"
4
5 ######################################################################
6
7 export CTDB_TIMEOUT=60
8
9 if [ -n "$CTDB_TEST_REMOTE_DIR" ] ; then
10     CTDB_TEST_WRAPPER="${CTDB_TEST_REMOTE_DIR}/test_wrap"
11 else
12     _d=$(cd ${TEST_SCRIPTS_DIR}; echo $PWD)
13     CTDB_TEST_WRAPPER="$_d/test_wrap"
14 fi
15 export CTDB_TEST_WRAPPER
16
17 # If $VALGRIND is set then use it whenever ctdb is called, but only if
18 # $CTDB is not already set.
19 [ -n "$CTDB" ] || export CTDB="${VALGRIND}${VALGRIND:+ }ctdb"
20
21 # why???
22 PATH="${TEST_SCRIPTS_DIR}:${PATH}"
23
24 ######################################################################
25
26 ctdb_test_exit ()
27 {
28     local status=$?
29
30     trap - 0
31
32     [ $(($testfailures+0)) -eq 0 -a $status -ne 0 ] && testfailures=$status
33     status=$(($testfailures+0))
34
35     # Avoid making a test fail from this point onwards.  The test is
36     # now complete.
37     set +e
38
39     echo "*** TEST COMPLETED (RC=$status) AT $(date '+%F %T'), CLEANING UP..."
40
41     eval "$ctdb_test_exit_hook" || true
42     unset ctdb_test_exit_hook
43
44     if $ctdb_test_restart_scheduled || ! cluster_is_healthy ; then
45
46         restart_ctdb
47     else
48         # This could be made unconditional but then we might get
49         # duplication from the recovery in restart_ctdb.  We want to
50         # leave the recovery in restart_ctdb so that future tests that
51         # might do a manual restart mid-test will benefit.
52         echo "Forcing a recovery..."
53         onnode 0 $CTDB recover
54     fi
55
56     exit $status
57 }
58
59 ctdb_test_exit_hook_add ()
60 {
61     ctdb_test_exit_hook="${ctdb_test_exit_hook}${ctdb_test_exit_hook:+ ; }$*"
62 }
63
64 ctdb_test_init ()
65 {
66     scriptname=$(basename "$0")
67     testfailures=0
68     ctdb_test_restart_scheduled=false
69
70     trap "ctdb_test_exit" 0
71 }
72
73 ########################################
74
75 # Sets: $out
76 try_command_on_node ()
77 {
78     local nodespec="$1" ; shift
79
80     local verbose=false
81     local onnode_opts=""
82
83     while [ "${nodespec#-}" != "$nodespec" ] ; do
84         if [ "$nodespec" = "-v" ] ; then
85             verbose=true
86         else
87             onnode_opts="${onnode_opts}${onnode_opts:+ }${nodespec}"
88         fi
89         nodespec="$1" ; shift
90     done
91
92     local cmd="$*"
93
94     out=$(onnode -q $onnode_opts "$nodespec" "$cmd" 2>&1) || {
95
96         echo "Failed to execute \"$cmd\" on node(s) \"$nodespec\""
97         echo "$out"
98         return 1
99     }
100
101     if $verbose ; then
102         echo "Output of \"$cmd\":"
103         echo "$out"
104     fi
105 }
106
107 sanity_check_output ()
108 {
109     local min_lines="$1"
110     local regexp="$2" # Should be anchored as necessary.
111     local output="$3"
112
113     local ret=0
114
115     local num_lines=$(echo "$output" | wc -l)
116     echo "There are $num_lines lines of output"
117     if [ $num_lines -lt $min_lines ] ; then
118         echo "BAD: that's less than the required number (${min_lines})"
119         ret=1
120     fi
121
122     local status=0
123     local unexpected # local doesn't pass through status of command on RHS.
124     unexpected=$(echo "$output" | egrep -v "$regexp") || status=$?
125
126     # Note that this is reversed.
127     if [ $status -eq 0 ] ; then
128         echo "BAD: unexpected lines in output:"
129         echo "$unexpected" | cat -A
130         ret=1
131     else
132         echo "Output lines look OK"
133     fi
134
135     return $ret
136 }
137
138 sanity_check_ips ()
139 {
140     local ips="$1" # list of "ip node" lines
141
142     echo "Sanity checking IPs..."
143
144     local x ipp prev
145     prev=""
146     while read x ipp ; do
147         [ "$ipp" = "-1" ] && break
148         if [ -n "$prev" -a "$ipp" != "$prev" ] ; then
149             echo "OK"
150             return 0
151         fi
152         prev="$ipp"
153     done <<<"$ips"
154
155     echo "BAD: a node was -1 or IPs are only assigned to one node:"
156     echo "$ips"
157     echo "Are you running an old version of CTDB?"
158     return 1
159 }
160
161 # This returns a list of "ip node" lines in $out
162 all_ips_on_node()
163 {
164     local node="$1"
165     try_command_on_node $node \
166         "$CTDB ip -X | awk -F'|' 'NR > 1 { print \$2, \$3 }'"
167 }
168
169 _select_test_node_and_ips ()
170 {
171     try_command_on_node any \
172         "$CTDB ip -X -n all | awk -F'|' 'NR > 1 { print \$2, \$3 }'"
173
174     test_node=""  # this matches no PNN
175     test_node_ips=""
176     local ip pnn
177     while read ip pnn ; do
178         if [ -z "$test_node" -a "$pnn" != "-1" ] ; then
179             test_node="$pnn"
180         fi
181         if [ "$pnn" = "$test_node" ] ; then
182             test_node_ips="${test_node_ips}${test_node_ips:+ }${ip}"
183         fi
184     done <<<"$out" # bashism to avoid problem setting variable in pipeline.
185
186     echo "Selected node ${test_node} with IPs: ${test_node_ips}."
187     test_ip="${test_node_ips%% *}"
188
189     [ -n "$test_node" ] || return 1
190 }
191
192 select_test_node_and_ips ()
193 {
194     local timeout=10
195     while ! _select_test_node_and_ips ; do
196         echo "Unable to find a test node with IPs assigned"
197         if [ $timeout -le 0 ] ; then
198             echo "BAD: Too many attempts"
199             return 1
200         fi
201         sleep_for 1
202         timeout=$(($timeout - 1))
203     done
204
205     return 0
206 }
207
208 # Sets: mask, iface
209 get_test_ip_mask_and_iface ()
210 {
211     # Find the interface
212     try_command_on_node $test_node "$CTDB ip -v -X | awk -F'|' -v ip=$test_ip '\$2 == ip { print \$4 }'"
213     iface="$out"
214
215     if [ -z "$TEST_LOCAL_DAEMONS" ] ; then
216         # Find the netmask
217         try_command_on_node $test_node ip addr show to $test_ip
218         mask="${out##*/}"
219         mask="${mask%% *}"
220     else
221         mask="24"
222     fi
223
224     echo "$test_ip/$mask is on $iface"
225 }
226
227 #######################################
228
229 # Wait until either timeout expires or command succeeds.  The command
230 # will be tried once per second, unless timeout has format T/I, where
231 # I is the recheck interval.
232 wait_until ()
233 {
234     local timeout="$1" ; shift # "$@" is the command...
235
236     local interval=1
237     case "$timeout" in
238         */*)
239             interval="${timeout#*/}"
240             timeout="${timeout%/*}"
241     esac
242
243     local negate=false
244     if [ "$1" = "!" ] ; then
245         negate=true
246         shift
247     fi
248
249     echo -n "<${timeout}|"
250     local t=$timeout
251     while [ $t -gt 0 ] ; do
252         local rc=0
253         "$@" || rc=$?
254         if { ! $negate && [ $rc -eq 0 ] ; } || \
255             { $negate && [ $rc -ne 0 ] ; } ; then
256             echo "|$(($timeout - $t))|"
257             echo "OK"
258             return 0
259         fi
260         local i
261         for i in $(seq 1 $interval) ; do
262             echo -n .
263         done
264         t=$(($t - $interval))
265         sleep $interval
266     done
267
268     echo "*TIMEOUT*"
269
270     return 1
271 }
272
273 sleep_for ()
274 {
275     echo -n "=${1}|"
276     for i in $(seq 1 $1) ; do
277         echo -n '.'
278         sleep 1
279     done
280     echo '|'
281 }
282
283 _cluster_is_healthy ()
284 {
285     $CTDB nodestatus all >/dev/null
286 }
287
288 _cluster_is_recovered ()
289 {
290     node_has_status all recovered
291 }
292
293 _cluster_is_ready ()
294 {
295     _cluster_is_healthy && _cluster_is_recovered
296 }
297
298 cluster_is_healthy ()
299 {
300     if onnode 0 $CTDB_TEST_WRAPPER _cluster_is_healthy ; then
301         echo "Cluster is HEALTHY"
302         if ! onnode 0 $CTDB_TEST_WRAPPER _cluster_is_recovered ; then
303           echo "WARNING: cluster in recovery mode!"
304         fi
305         return 0
306     else
307         echo "Cluster is UNHEALTHY"
308         if ! ${ctdb_test_restart_scheduled:-false} ; then
309             echo "DEBUG AT $(date '+%F %T'):"
310             local i
311             for i in "onnode -q 0 $CTDB status" "onnode -q 0 onnode all $CTDB scriptstatus" ; do
312                 echo "$i"
313                 $i || true
314             done
315         fi
316         return 1
317     fi
318 }
319
320 wait_until_ready ()
321 {
322     local timeout="${1:-120}"
323
324     echo "Waiting for cluster to become ready..."
325
326     wait_until $timeout onnode -q any $CTDB_TEST_WRAPPER _cluster_is_ready
327 }
328
329 # This function is becoming nicely overloaded.  Soon it will collapse!  :-)
330 node_has_status ()
331 {
332     local pnn="$1"
333     local status="$2"
334
335     local bits fpat mpat rpat
336     case "$status" in
337         (unhealthy)    bits="?|?|?|1|*" ;;
338         (healthy)      bits="?|?|?|0|*" ;;
339         (disconnected) bits="1|*" ;;
340         (connected)    bits="0|*" ;;
341         (banned)       bits="?|1|*" ;;
342         (unbanned)     bits="?|0|*" ;;
343         (disabled)     bits="?|?|1|*" ;;
344         (enabled)      bits="?|?|0|*" ;;
345         (stopped)      bits="?|?|?|?|1|*" ;;
346         (notstopped)   bits="?|?|?|?|0|*" ;;
347         (frozen)       fpat='^[[:space:]]+frozen[[:space:]]+1$' ;;
348         (unfrozen)     fpat='^[[:space:]]+frozen[[:space:]]+0$' ;;
349         (monon)        mpat='^Monitoring mode:ACTIVE \(0\)$' ;;
350         (monoff)       mpat='^Monitoring mode:DISABLED \(1\)$' ;;
351         (recovered)    rpat='^Recovery mode:RECOVERY \(1\)$' ;;
352         *)
353             echo "node_has_status: unknown status \"$status\""
354             return 1
355     esac
356
357     if [ -n "$bits" ] ; then
358         local out x line
359
360         out=$($CTDB -X status 2>&1) || return 1
361
362         {
363             read x
364             while read line ; do
365                 # This needs to be done in 2 steps to avoid false matches.
366                 local line_bits="${line#|${pnn}|*|}"
367                 [ "$line_bits" = "$line" ] && continue
368                 [ "${line_bits#${bits}}" != "$line_bits" ] && return 0
369             done
370             return 1
371         } <<<"$out" # Yay bash!
372     elif [ -n "$fpat" ] ; then
373         $CTDB statistics -n "$pnn" | egrep -q "$fpat"
374     elif [ -n "$mpat" ] ; then
375         $CTDB getmonmode -n "$pnn" | egrep -q "$mpat"
376     elif [ -n "$rpat" ] ; then
377         ! $CTDB status -n "$pnn" | egrep -q "$rpat"
378     else
379         echo 'node_has_status: unknown mode, neither $bits nor $fpat is set'
380         return 1
381     fi
382 }
383
384 wait_until_node_has_status ()
385 {
386     local pnn="$1"
387     local status="$2"
388     local timeout="${3:-30}"
389     local proxy_pnn="${4:-any}"
390
391     echo "Waiting until node $pnn has status \"$status\"..."
392
393     if ! wait_until $timeout onnode $proxy_pnn $CTDB_TEST_WRAPPER node_has_status "$pnn" "$status" ; then
394         for i in "onnode -q any $CTDB status" "onnode -q any onnode all $CTDB scriptstatus" ; do
395             echo "$i"
396             $i || true
397         done
398
399         return 1
400     fi
401
402 }
403
404 # Useful for superficially testing IP failover.
405 # IPs must be on the given node.
406 # If the first argument is '!' then the IPs must not be on the given node.
407 ips_are_on_node ()
408 {
409     local negating=false
410     if [ "$1" = "!" ] ; then
411         negating=true ; shift
412     fi
413     local node="$1" ; shift
414     local ips="$*"
415
416     local out
417
418     all_ips_on_node $node
419
420     local check
421     for check in $ips ; do
422         local ip pnn
423         while read ip pnn ; do
424             if [ "$check" = "$ip" ] ; then
425                 if [ "$pnn" = "$node" ] ; then
426                     if $negating ; then return 1 ; fi
427                 else
428                     if ! $negating ; then return 1 ; fi
429                 fi
430                 ips="${ips/${ip}}" # Remove from list
431                 break
432             fi
433             # If we're negating and we didn't see the address then it
434             # isn't hosted by anyone!
435             if $negating ; then
436                 ips="${ips/${check}}"
437             fi
438         done <<<"$out" # bashism to avoid problem setting variable in pipeline.
439     done
440
441     ips="${ips// }" # Remove any spaces.
442     [ -z "$ips" ]
443 }
444
445 wait_until_ips_are_on_node ()
446 {
447     # Go to some trouble to print a use description of what is happening
448     local not=""
449     if [ "$1" == "!" ] ; then
450         not="no longer "
451     fi
452     local node=""
453     local ips=""
454     local i
455     for i ; do
456         [ "$i" != "!" ] || continue
457         if [ -z "$node" ] ; then
458             node="$i"
459             continue
460         fi
461         ips="${ips}${ips:+, }${i}"
462     done
463     echo "Waiting for ${ips} to ${not}be assigned to node ${node}"
464
465     wait_until 60 ips_are_on_node "$@"
466 }
467
468 node_has_some_ips ()
469 {
470     local node="$1"
471
472     local out
473
474     all_ips_on_node $node
475
476     while read ip pnn ; do
477         if [ "$node" = "$pnn" ] ; then
478             return 0
479         fi
480     done <<<"$out" # bashism to avoid problem setting variable in pipeline.
481
482     return 1
483 }
484
485 wait_until_node_has_some_ips ()
486 {
487     echo "Waiting for some IPs to be assigned to node ${test_node}"
488
489     wait_until 60 node_has_some_ips "$@"
490 }
491
492 #######################################
493
494 _ctdb_hack_options ()
495 {
496     local ctdb_options="$*"
497
498     case "$ctdb_options" in
499         *--start-as-stopped*)
500             export CTDB_START_AS_STOPPED="yes"
501     esac
502 }
503
504 restart_ctdb_1 ()
505 {
506     _ctdb_hack_options "$@"
507
508     if [ -e /etc/redhat-release ] ; then
509         service ctdb restart
510     else
511         /etc/init.d/ctdb restart
512     fi
513 }
514
515 # Restart CTDB on all nodes.  Override for local daemons.
516 _restart_ctdb_all ()
517 {
518     onnode -p all $CTDB_TEST_WRAPPER restart_ctdb_1 "$@"
519 }
520
521 # Nothing needed for a cluster.  Override for local daemons.
522 setup_ctdb ()
523 {
524     :
525 }
526
527 restart_ctdb ()
528 {
529     # "$@" is passed to restart_ctdb_all.
530
531     echo -n "Restarting CTDB"
532     if $ctdb_test_restart_scheduled ; then
533         echo -n " (scheduled)"
534     fi
535     echo "..."
536
537     local i
538     for i in $(seq 1 5) ; do
539         _restart_ctdb_all "$@" || {
540             echo "Restart failed.  Trying again in a few seconds..."
541             sleep_for 5
542             continue
543         }
544
545         wait_until_ready || {
546             echo "Cluster didn't become ready.  Restarting..."
547             continue
548         }
549
550         echo "Setting RerecoveryTimeout to 1"
551         onnode -pq all "$CTDB setvar RerecoveryTimeout 1"
552
553         # In recent versions of CTDB, forcing a recovery like this
554         # blocks until the recovery is complete.  Hopefully this will
555         # help the cluster to stabilise before a subsequent test.
556         echo "Forcing a recovery..."
557         onnode -q 0 $CTDB recover
558         sleep_for 2
559
560         if ! onnode -q any $CTDB_TEST_WRAPPER _cluster_is_recovered ; then
561             echo "Cluster has gone into recovery again, waiting..."
562             wait_until 30/2 onnode -q any $CTDB_TEST_WRAPPER _cluster_is_recovered
563         fi
564
565
566         # Cluster is still healthy.  Good, we're done!
567         if ! onnode 0 $CTDB_TEST_WRAPPER _cluster_is_healthy ; then
568             echo "Cluster became UNHEALTHY again [$(date)]"
569             onnode -p all ctdb status -X 2>&1
570             onnode -p all ctdb scriptstatus 2>&1
571             echo "Restarting..."
572             continue
573         fi
574
575         echo "Doing a sync..."
576         onnode -q 0 $CTDB sync
577
578         echo "ctdb is ready"
579         return 0
580     done
581
582     echo "Cluster UNHEALTHY...  too many attempts..."
583     onnode -p all ctdb status -X 2>&1
584     onnode -p all ctdb scriptstatus 2>&1
585
586     # Try to make the calling test fail
587     status=1
588     return 1
589 }
590
591 # Does nothing on cluster and should be overridden for local daemons
592 maybe_stop_ctdb ()
593 {
594     :
595 }
596
597 ctdb_restart_when_done ()
598 {
599     ctdb_test_restart_scheduled=true
600 }
601
602 get_ctdbd_command_line_option ()
603 {
604     local pnn="$1"
605     local option="$2"
606
607     try_command_on_node "$pnn" "$CTDB getpid" || \
608         die "Unable to get PID of ctdbd on node $pnn"
609
610     local pid="${out#*:}"
611     try_command_on_node "$pnn" "ps -p $pid -o args hww" || \
612         die "Unable to get command-line of PID $pid"
613
614     # Strip everything up to and including --option
615     local t="${out#*--${option}}"
616     # Strip leading '=' or space if present
617     t="${t#=}"
618     t="${t# }"
619     # Strip any following options and print
620     echo "${t%% -*}"
621 }
622
623 #######################################
624
625 wait_for_monitor_event ()
626 {
627     local pnn="$1"
628     local timeout=120
629
630     echo "Waiting for a monitor event on node ${pnn}..."
631
632     try_command_on_node "$pnn" $CTDB scriptstatus || {
633         echo "Unable to get scriptstatus from node $pnn"
634         return 1
635     }
636
637     local ctdb_scriptstatus_original="$out"
638     wait_until 120 _ctdb_scriptstatus_changed
639 }
640
641 _ctdb_scriptstatus_changed ()
642 {
643     try_command_on_node "$pnn" $CTDB scriptstatus || {
644         echo "Unable to get scriptstatus from node $pnn"
645         return 1
646     }
647
648     [ "$out" != "$ctdb_scriptstatus_original" ]
649 }
650
651 #######################################
652
653 nfs_test_setup ()
654 {
655     select_test_node_and_ips
656
657     nfs_first_export=$(showmount -e $test_ip | sed -n -e '2s/ .*//p')
658
659     echo "Creating test subdirectory..."
660     try_command_on_node $test_node "mktemp -d --tmpdir=$nfs_first_export"
661     nfs_test_dir="$out"
662     try_command_on_node $test_node "chmod 777 $nfs_test_dir"
663
664     nfs_mnt_d=$(mktemp -d)
665     nfs_local_file="${nfs_mnt_d}/${nfs_test_dir##*/}/TEST_FILE"
666     nfs_remote_file="${nfs_test_dir}/TEST_FILE"
667
668     ctdb_test_exit_hook_add nfs_test_cleanup
669
670     echo "Mounting ${test_ip}:${nfs_first_export} on ${nfs_mnt_d} ..."
671     mount -o timeo=1,hard,intr,vers=3 \
672         ${test_ip}:${nfs_first_export} ${nfs_mnt_d}
673 }
674
675 nfs_test_cleanup ()
676 {
677     rm -f "$nfs_local_file"
678     umount -f "$nfs_mnt_d"
679     rmdir "$nfs_mnt_d"
680     onnode -q $test_node rmdir "$nfs_test_dir"
681 }
682
683 #######################################
684
685 # $1: pnn, $2: DB name
686 db_get_path ()
687 {
688     try_command_on_node -v $1 $CTDB getdbstatus "$2" |
689     sed -n -e "s@^path: @@p"
690 }
691
692 # $1: pnn, $2: DB name
693 db_ctdb_cattdb_count_records ()
694 {
695     try_command_on_node -v $1 $CTDB cattdb "$2" |
696     grep '^key' | grep -v '__db_sequence_number__' |
697     wc -l
698 }
699
700 # $1: pnn, $2: DB name, $3: key string, $4: value string, $5: RSN (default 7)
701 db_ctdb_tstore ()
702 {
703     _tdb=$(db_get_path $1 "$2")
704     _rsn="${5:-7}"
705     try_command_on_node $1 $CTDB tstore "$_tdb" "$3" "$4" "$_rsn"
706 }
707
708 # $1: pnn, $2: DB name, $3: dbseqnum (must be < 255!!!!!)
709 db_ctdb_tstore_dbseqnum ()
710 {
711     # "__db_sequence_number__" + trailing 0x00
712     _key='0x5f5f64625f73657175656e63655f6e756d6265725f5f00'
713
714     # Construct 8 byte (unit64_t) database sequence number.  This
715     # probably breaks if $3 > 255
716     _value=$(printf "0x%02x%014x" $3 0)
717
718     db_ctdb_tstore $1 "$2" "$_key" "$_value"
719 }
720
721 #######################################
722
723 # Make sure that $CTDB is set.
724 : ${CTDB:=ctdb}
725
726 local="${TEST_SUBDIR}/scripts/local.bash"
727 if [ -r "$local" ] ; then
728     . "$local"
729 fi