ctdb-protocol: Fix marshalling for ctdb_uptime
[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 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     case "$test_ip" in
190         *:*) test_prefix="${test_ip}/128" ;;
191         *)   test_prefix="${test_ip}/32"  ;;
192     esac
193
194     [ -n "$test_node" ] || return 1
195 }
196
197 select_test_node_and_ips ()
198 {
199     local timeout=10
200     while ! _select_test_node_and_ips ; do
201         echo "Unable to find a test node with IPs assigned"
202         if [ $timeout -le 0 ] ; then
203             echo "BAD: Too many attempts"
204             return 1
205         fi
206         sleep_for 1
207         timeout=$(($timeout - 1))
208     done
209
210     return 0
211 }
212
213 # Sets: mask, iface
214 get_test_ip_mask_and_iface ()
215 {
216     # Find the interface
217     try_command_on_node $test_node "$CTDB ip -v -X | awk -F'|' -v ip=$test_ip '\$2 == ip { print \$4 }'"
218     iface="$out"
219
220     if [ -z "$TEST_LOCAL_DAEMONS" ] ; then
221         # Find the netmask
222         try_command_on_node $test_node ip addr show to $test_ip
223         mask="${out##*/}"
224         mask="${mask%% *}"
225     else
226         mask="24"
227     fi
228
229     echo "$test_ip/$mask is on $iface"
230 }
231
232 ctdb_get_all_pnns ()
233 {
234     try_command_on_node -q all "$CTDB pnn"
235     all_pnns="$out"
236 }
237
238 # The subtlety is that "ctdb delip" will fail if the IP address isn't
239 # configured on a node...
240 delete_ip_from_all_nodes ()
241 {
242     _ip="$1"
243
244     ctdb_get_all_pnns
245
246     _nodes=""
247
248     for _pnn in $all_pnns ; do
249         all_ips_on_node $_pnn
250         while read _i _n ; do
251             if [ "$_ip" = "$_i" ] ; then
252                 _nodes="${_nodes}${_nodes:+,}${_pnn}"
253             fi
254         done <<<"$out" # bashism
255     done
256
257     try_command_on_node -pq "$_nodes" "$CTDB delip $_ip"
258 }
259
260 #######################################
261
262 # Wait until either timeout expires or command succeeds.  The command
263 # will be tried once per second, unless timeout has format T/I, where
264 # I is the recheck interval.
265 wait_until ()
266 {
267     local timeout="$1" ; shift # "$@" is the command...
268
269     local interval=1
270     case "$timeout" in
271         */*)
272             interval="${timeout#*/}"
273             timeout="${timeout%/*}"
274     esac
275
276     local negate=false
277     if [ "$1" = "!" ] ; then
278         negate=true
279         shift
280     fi
281
282     echo -n "<${timeout}|"
283     local t=$timeout
284     while [ $t -gt 0 ] ; do
285         local rc=0
286         "$@" || rc=$?
287         if { ! $negate && [ $rc -eq 0 ] ; } || \
288             { $negate && [ $rc -ne 0 ] ; } ; then
289             echo "|$(($timeout - $t))|"
290             echo "OK"
291             return 0
292         fi
293         local i
294         for i in $(seq 1 $interval) ; do
295             echo -n .
296         done
297         t=$(($t - $interval))
298         sleep $interval
299     done
300
301     echo "*TIMEOUT*"
302
303     return 1
304 }
305
306 sleep_for ()
307 {
308     echo -n "=${1}|"
309     for i in $(seq 1 $1) ; do
310         echo -n '.'
311         sleep 1
312     done
313     echo '|'
314 }
315
316 _cluster_is_healthy ()
317 {
318     $CTDB nodestatus all >/dev/null
319 }
320
321 _cluster_is_recovered ()
322 {
323     node_has_status 0 recovered
324 }
325
326 _cluster_is_ready ()
327 {
328     _cluster_is_healthy && _cluster_is_recovered
329 }
330
331 cluster_is_healthy ()
332 {
333     if onnode 0 $CTDB_TEST_WRAPPER _cluster_is_healthy ; then
334         echo "Cluster is HEALTHY"
335         if ! onnode 0 $CTDB_TEST_WRAPPER _cluster_is_recovered ; then
336           echo "WARNING: cluster in recovery mode!"
337         fi
338         return 0
339     else
340         echo "Cluster is UNHEALTHY"
341         if ! ${ctdb_test_restart_scheduled:-false} ; then
342             echo "DEBUG AT $(date '+%F %T'):"
343             local i
344             for i in "onnode -q 0 $CTDB status" "onnode -q 0 onnode all $CTDB scriptstatus" ; do
345                 echo "$i"
346                 $i || true
347             done
348         fi
349         return 1
350     fi
351 }
352
353 wait_until_ready ()
354 {
355     local timeout="${1:-120}"
356
357     echo "Waiting for cluster to become ready..."
358
359     wait_until $timeout onnode -q any $CTDB_TEST_WRAPPER _cluster_is_ready
360 }
361
362 # This function is becoming nicely overloaded.  Soon it will collapse!  :-)
363 node_has_status ()
364 {
365     local pnn="$1"
366     local status="$2"
367
368     local bits fpat mpat rpat
369     case "$status" in
370         (unhealthy)    bits="?|?|?|1|*" ;;
371         (healthy)      bits="?|?|?|0|*" ;;
372         (disconnected) bits="1|*" ;;
373         (connected)    bits="0|*" ;;
374         (banned)       bits="?|1|*" ;;
375         (unbanned)     bits="?|0|*" ;;
376         (disabled)     bits="?|?|1|*" ;;
377         (enabled)      bits="?|?|0|*" ;;
378         (stopped)      bits="?|?|?|?|1|*" ;;
379         (notstopped)   bits="?|?|?|?|0|*" ;;
380         (frozen)       fpat='^[[:space:]]+frozen[[:space:]]+1$' ;;
381         (unfrozen)     fpat='^[[:space:]]+frozen[[:space:]]+0$' ;;
382         (monon)        mpat='^Monitoring mode:ACTIVE \(0\)$' ;;
383         (monoff)       mpat='^Monitoring mode:DISABLED \(1\)$' ;;
384         (recovered)    rpat='^Recovery mode:RECOVERY \(1\)$' ;;
385         *)
386             echo "node_has_status: unknown status \"$status\""
387             return 1
388     esac
389
390     if [ -n "$bits" ] ; then
391         local out x line
392
393         out=$($CTDB -X status 2>&1) || return 1
394
395         {
396             read x
397             while read line ; do
398                 # This needs to be done in 2 steps to avoid false matches.
399                 local line_bits="${line#|${pnn}|*|}"
400                 [ "$line_bits" = "$line" ] && continue
401                 [ "${line_bits#${bits}}" != "$line_bits" ] && return 0
402             done
403             return 1
404         } <<<"$out" # Yay bash!
405     elif [ -n "$fpat" ] ; then
406         $CTDB statistics -n "$pnn" | egrep -q "$fpat"
407     elif [ -n "$mpat" ] ; then
408         $CTDB getmonmode -n "$pnn" | egrep -q "$mpat"
409     elif [ -n "$rpat" ] ; then
410         ! $CTDB status -n "$pnn" | egrep -q "$rpat"
411     else
412         echo 'node_has_status: unknown mode, neither $bits nor $fpat is set'
413         return 1
414     fi
415 }
416
417 wait_until_node_has_status ()
418 {
419     local pnn="$1"
420     local status="$2"
421     local timeout="${3:-30}"
422     local proxy_pnn="${4:-any}"
423
424     echo "Waiting until node $pnn has status \"$status\"..."
425
426     if ! wait_until $timeout onnode $proxy_pnn $CTDB_TEST_WRAPPER node_has_status "$pnn" "$status" ; then
427         for i in "onnode -q any $CTDB status" "onnode -q any onnode all $CTDB scriptstatus" ; do
428             echo "$i"
429             $i || true
430         done
431
432         return 1
433     fi
434
435 }
436
437 # Useful for superficially testing IP failover.
438 # IPs must be on the given node.
439 # If the first argument is '!' then the IPs must not be on the given node.
440 ips_are_on_node ()
441 {
442     local negating=false
443     if [ "$1" = "!" ] ; then
444         negating=true ; shift
445     fi
446     local node="$1" ; shift
447     local ips="$*"
448
449     local out
450
451     all_ips_on_node $node
452
453     local check
454     for check in $ips ; do
455         local ip pnn
456         while read ip pnn ; do
457             if [ "$check" = "$ip" ] ; then
458                 if [ "$pnn" = "$node" ] ; then
459                     if $negating ; then return 1 ; fi
460                 else
461                     if ! $negating ; then return 1 ; fi
462                 fi
463                 ips="${ips/${ip}}" # Remove from list
464                 break
465             fi
466             # If we're negating and we didn't see the address then it
467             # isn't hosted by anyone!
468             if $negating ; then
469                 ips="${ips/${check}}"
470             fi
471         done <<<"$out" # bashism to avoid problem setting variable in pipeline.
472     done
473
474     ips="${ips// }" # Remove any spaces.
475     [ -z "$ips" ]
476 }
477
478 wait_until_ips_are_on_node ()
479 {
480     # Go to some trouble to print a use description of what is happening
481     local not=""
482     if [ "$1" == "!" ] ; then
483         not="no longer "
484     fi
485     local node=""
486     local ips=""
487     local i
488     for i ; do
489         [ "$i" != "!" ] || continue
490         if [ -z "$node" ] ; then
491             node="$i"
492             continue
493         fi
494         ips="${ips}${ips:+, }${i}"
495     done
496     echo "Waiting for ${ips} to ${not}be assigned to node ${node}"
497
498     wait_until 60 ips_are_on_node "$@"
499 }
500
501 node_has_some_ips ()
502 {
503     local node="$1"
504
505     local out
506
507     all_ips_on_node $node
508
509     while read ip pnn ; do
510         if [ "$node" = "$pnn" ] ; then
511             return 0
512         fi
513     done <<<"$out" # bashism to avoid problem setting variable in pipeline.
514
515     return 1
516 }
517
518 wait_until_node_has_some_ips ()
519 {
520     echo "Waiting for some IPs to be assigned to node ${test_node}"
521
522     wait_until 60 node_has_some_ips "$@"
523 }
524
525 #######################################
526
527 _service_ctdb ()
528 {
529     cmd="$1"
530
531     if [ -e /etc/redhat-release ] ; then
532         service ctdb "$cmd"
533     else
534         /etc/init.d/ctdb "$cmd"
535     fi
536 }
537
538 # Restart CTDB on all nodes.  Override for local daemons.
539 _restart_ctdb_all ()
540 {
541     onnode -p all $CTDB_TEST_WRAPPER _service_ctdb restart
542 }
543
544 # Nothing needed for a cluster.  Override for local daemons.
545 setup_ctdb ()
546 {
547     :
548 }
549
550 start_ctdb_1 ()
551 {
552     onnode "$1" $CTDB_TEST_WRAPPER _service_ctdb start
553 }
554
555 stop_ctdb_1 ()
556 {
557     onnode "$1" $CTDB_TEST_WRAPPER _service_ctdb stop
558 }
559
560 restart_ctdb_1 ()
561 {
562     onnode "$1" $CTDB_TEST_WRAPPER _service_ctdb restart
563 }
564
565 restart_ctdb ()
566 {
567     echo -n "Restarting CTDB"
568     if $ctdb_test_restart_scheduled ; then
569         echo -n " (scheduled)"
570     fi
571     echo "..."
572
573     local i
574     for i in $(seq 1 5) ; do
575         _restart_ctdb_all || {
576             echo "Restart failed.  Trying again in a few seconds..."
577             sleep_for 5
578             continue
579         }
580
581         wait_until_ready || {
582             echo "Cluster didn't become ready.  Restarting..."
583             continue
584         }
585
586         echo "Setting RerecoveryTimeout to 1"
587         onnode -pq all "$CTDB setvar RerecoveryTimeout 1"
588
589         # In recent versions of CTDB, forcing a recovery like this
590         # blocks until the recovery is complete.  Hopefully this will
591         # help the cluster to stabilise before a subsequent test.
592         echo "Forcing a recovery..."
593         onnode -q 0 $CTDB recover
594         sleep_for 2
595
596         if ! onnode -q any $CTDB_TEST_WRAPPER _cluster_is_recovered ; then
597             echo "Cluster has gone into recovery again, waiting..."
598             wait_until 30/2 onnode -q any $CTDB_TEST_WRAPPER _cluster_is_recovered
599         fi
600
601
602         # Cluster is still healthy.  Good, we're done!
603         if ! onnode 0 $CTDB_TEST_WRAPPER _cluster_is_healthy ; then
604             echo "Cluster became UNHEALTHY again [$(date)]"
605             onnode -p all ctdb status -X 2>&1
606             onnode -p all ctdb scriptstatus 2>&1
607             echo "Restarting..."
608             continue
609         fi
610
611         echo "Doing a sync..."
612         onnode -q 0 $CTDB sync
613
614         echo "ctdb is ready"
615         return 0
616     done
617
618     echo "Cluster UNHEALTHY...  too many attempts..."
619     onnode -p all ctdb status -X 2>&1
620     onnode -p all ctdb scriptstatus 2>&1
621
622     # Try to make the calling test fail
623     status=1
624     return 1
625 }
626
627 # Does nothing on cluster and should be overridden for local daemons
628 maybe_stop_ctdb ()
629 {
630     :
631 }
632
633 ctdb_restart_when_done ()
634 {
635     ctdb_test_restart_scheduled=true
636 }
637
638 get_ctdbd_command_line_option ()
639 {
640     local pnn="$1"
641     local option="$2"
642
643     try_command_on_node "$pnn" "$CTDB getpid" || \
644         die "Unable to get PID of ctdbd on node $pnn"
645
646     local pid="${out#*:}"
647     try_command_on_node "$pnn" "ps -p $pid -o args hww" || \
648         die "Unable to get command-line of PID $pid"
649
650     # Strip everything up to and including --option
651     local t="${out#*--${option}}"
652     # Strip leading '=' or space if present
653     t="${t#=}"
654     t="${t# }"
655     # Strip any following options and print
656     echo "${t%% -*}"
657 }
658
659 #######################################
660
661 wait_for_monitor_event ()
662 {
663     local pnn="$1"
664     local timeout=120
665
666     echo "Waiting for a monitor event on node ${pnn}..."
667
668     try_command_on_node "$pnn" $CTDB scriptstatus || {
669         echo "Unable to get scriptstatus from node $pnn"
670         return 1
671     }
672
673     local ctdb_scriptstatus_original="$out"
674     wait_until 120 _ctdb_scriptstatus_changed
675 }
676
677 _ctdb_scriptstatus_changed ()
678 {
679     try_command_on_node "$pnn" $CTDB scriptstatus || {
680         echo "Unable to get scriptstatus from node $pnn"
681         return 1
682     }
683
684     [ "$out" != "$ctdb_scriptstatus_original" ]
685 }
686
687 #######################################
688
689 nfs_test_setup ()
690 {
691     select_test_node_and_ips
692
693     nfs_first_export=$(showmount -e $test_ip | sed -n -e '2s/ .*//p')
694
695     echo "Creating test subdirectory..."
696     try_command_on_node $test_node "mktemp -d --tmpdir=$nfs_first_export"
697     nfs_test_dir="$out"
698     try_command_on_node $test_node "chmod 777 $nfs_test_dir"
699
700     nfs_mnt_d=$(mktemp -d)
701     nfs_local_file="${nfs_mnt_d}/${nfs_test_dir##*/}/TEST_FILE"
702     nfs_remote_file="${nfs_test_dir}/TEST_FILE"
703
704     ctdb_test_exit_hook_add nfs_test_cleanup
705
706     echo "Mounting ${test_ip}:${nfs_first_export} on ${nfs_mnt_d} ..."
707     mount -o timeo=1,hard,intr,vers=3 \
708         "[${test_ip}]:${nfs_first_export}" ${nfs_mnt_d}
709 }
710
711 nfs_test_cleanup ()
712 {
713     rm -f "$nfs_local_file"
714     umount -f "$nfs_mnt_d"
715     rmdir "$nfs_mnt_d"
716     onnode -q $test_node rmdir "$nfs_test_dir"
717 }
718
719 #######################################
720
721 # If the given IP is hosted then print 2 items: maskbits and iface
722 ip_maskbits_iface ()
723 {
724     _addr="$1"
725
726     case "$_addr" in
727         *:*) _family="inet6" ; _bits=128 ;;
728         *)   _family="inet"  ; _bits=32  ;;
729     esac
730
731     ip addr show to "${_addr}/${_bits}" 2>/dev/null | \
732         awk -v family="${_family}" \
733             'NR == 1 { iface = $2; sub(":$", "", iface) } \
734              $1 ~ /inet/ { mask = $2; sub(".*/", "", mask); \
735                            print mask, iface, family }'
736 }
737
738 drop_ip ()
739 {
740     _addr="${1%/*}"  # Remove optional maskbits
741
742     set -- $(ip_maskbits_iface $_addr)
743     if [ -n "$1" ] ; then
744         _maskbits="$1"
745         _iface="$2"
746         echo "Removing public address $_addr/$_maskbits from device $_iface"
747         ip addr del "$_ip/$_maskbits" dev "$_iface" >/dev/null 2>&1 || true
748     fi
749 }
750
751 drop_ips ()
752 {
753     for _ip ; do
754         drop_ip "$_ip"
755     done
756 }
757
758 #######################################
759
760 # $1: pnn, $2: DB name
761 db_get_path ()
762 {
763     try_command_on_node -v $1 $CTDB getdbstatus "$2" |
764     sed -n -e "s@^path: @@p"
765 }
766
767 # $1: pnn, $2: DB name
768 db_ctdb_cattdb_count_records ()
769 {
770     try_command_on_node -v $1 $CTDB cattdb "$2" |
771     grep '^key' | grep -v '__db_sequence_number__' |
772     wc -l
773 }
774
775 # $1: pnn, $2: DB name, $3: key string, $4: value string, $5: RSN (default 7)
776 db_ctdb_tstore ()
777 {
778     _tdb=$(db_get_path $1 "$2")
779     _rsn="${5:-7}"
780     try_command_on_node $1 $CTDB tstore "$_tdb" "$3" "$4" "$_rsn"
781 }
782
783 # $1: pnn, $2: DB name, $3: dbseqnum (must be < 255!!!!!)
784 db_ctdb_tstore_dbseqnum ()
785 {
786     # "__db_sequence_number__" + trailing 0x00
787     _key='0x5f5f64625f73657175656e63655f6e756d6265725f5f00'
788
789     # Construct 8 byte (unit64_t) database sequence number.  This
790     # probably breaks if $3 > 255
791     _value=$(printf "0x%02x%014x" $3 0)
792
793     db_ctdb_tstore $1 "$2" "$_key" "$_value"
794 }
795
796 #######################################
797
798 # Make sure that $CTDB is set.
799 : ${CTDB:=ctdb}
800
801 local="${TEST_SUBDIR}/scripts/local.bash"
802 if [ -r "$local" ] ; then
803     . "$local"
804 fi