winbind: Fix a memleak
[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_on_cluster ()
27 {
28         [ -z "$CTDB_TEST_LOCAL_DAEMONS" ]
29 }
30
31 ctdb_test_exit ()
32 {
33     local status=$?
34
35     trap - 0
36
37     # run_tests.sh pipes stdout into tee.  If the tee process is
38     # killed then any attempt to write to stdout (e.g. echo) will
39     # result in SIGPIPE, terminating the caller.  Ignore SIGPIPE to
40     # ensure that all clean-up is run.
41     trap '' PIPE
42
43     # Avoid making a test fail from this point onwards.  The test is
44     # now complete.
45     set +e
46
47     echo "*** TEST COMPLETED (RC=$status) AT $(date '+%F %T'), CLEANING UP..."
48
49     eval "$ctdb_test_exit_hook" || true
50     unset ctdb_test_exit_hook
51
52     echo "Stopping cluster..."
53     ctdb_nodes_stop || ctdb_test_error "Cluster shutdown failed"
54
55     exit $status
56 }
57
58 ctdb_test_exit_hook_add ()
59 {
60     ctdb_test_exit_hook="${ctdb_test_exit_hook}${ctdb_test_exit_hook:+ ; }$*"
61 }
62
63 # Setting cleanup_pid to <pid>@<node> will cause <pid> to be killed on
64 # <node> when the test completes.  To cancel, just unset cleanup_pid.
65 ctdb_test_cleanup_pid=""
66 ctdb_test_cleanup_pid_exit_hook ()
67 {
68         if [ -n "$ctdb_test_cleanup_pid" ] ; then
69                 local pid="${ctdb_test_cleanup_pid%@*}"
70                 local node="${ctdb_test_cleanup_pid#*@}"
71
72                 try_command_on_node "$node" "kill ${pid}"
73         fi
74 }
75
76 ctdb_test_exit_hook_add ctdb_test_cleanup_pid_exit_hook
77
78 ctdb_test_cleanup_pid_set ()
79 {
80         local node="$1"
81         local pid="$2"
82
83         ctdb_test_cleanup_pid="${pid}@${node}"
84 }
85
86 ctdb_test_cleanup_pid_clear ()
87 {
88         ctdb_test_cleanup_pid=""
89 }
90
91 # -n option means do not configure/start cluster
92 ctdb_test_init ()
93 {
94         trap "ctdb_test_exit" 0
95
96         ctdb_nodes_stop >/dev/null 2>&1 || true
97
98         if [ "$1" != "-n" ] ; then
99                 echo "Configuring cluster..."
100                 setup_ctdb || ctdb_test_error "Cluster configuration failed"
101
102                 echo "Starting cluster..."
103                 ctdb_init || ctdb_test_error "Cluster startup failed"
104         fi
105
106         echo  "*** SETUP COMPLETE AT $(date '+%F %T'), RUNNING TEST..."
107 }
108
109 ctdb_nodes_start_custom ()
110 {
111         if ctdb_test_on_cluster ; then
112                 ctdb_test_error "ctdb_nodes_start_custom() on real cluster"
113         fi
114
115         ctdb_nodes_stop >/dev/null 2>&1 || true
116
117         echo "Configuring cluster..."
118         setup_ctdb "$@" || ctdb_test_error "Cluster configuration failed"
119
120         echo "Starting cluster..."
121         ctdb_init || ctdb_test_fail "Cluster startup failed"
122 }
123
124 ctdb_test_skip_on_cluster ()
125 {
126         if ctdb_test_on_cluster ; then
127                 ctdb_test_skip \
128                         "SKIPPING this test - only runs against local daemons"
129         fi
130 }
131
132
133 ctdb_nodes_restart ()
134 {
135         ctdb_nodes_stop "$@"
136         ctdb_nodes_start "$@"
137 }
138
139 ########################################
140
141 # Sets: $out, $outfile
142 # * The first 1KB of output is put into $out
143 # * Tests should use $outfile for handling large output
144 # * $outfile is removed after each test
145 out=""
146 outfile="${CTDB_TEST_TMP_DIR}/try_command_on_node.out"
147
148 outfile_cleanup ()
149 {
150         rm -f "$outfile"
151 }
152
153 ctdb_test_exit_hook_add outfile_cleanup
154
155 try_command_on_node ()
156 {
157     local nodespec="$1" ; shift
158
159     local verbose=false
160     local onnode_opts=""
161
162     while [ "${nodespec#-}" != "$nodespec" ] ; do
163         if [ "$nodespec" = "-v" ] ; then
164             verbose=true
165         else
166             onnode_opts="${onnode_opts}${onnode_opts:+ }${nodespec}"
167         fi
168         nodespec="$1" ; shift
169     done
170
171     local cmd="$*"
172
173     local status=0
174     # Intentionally unquoted - might be empty
175     # shellcheck disable=SC2086
176     onnode -q $onnode_opts "$nodespec" "$cmd" >"$outfile" 2>&1 || status=$?
177     out=$(dd if="$outfile" bs=1k count=1 2>/dev/null)
178
179     if [ $status -ne 0 ] ; then
180         echo "Failed to execute \"$cmd\" on node(s) \"$nodespec\""
181         cat "$outfile"
182         return $status
183     fi
184
185     if $verbose ; then
186         echo "Output of \"$cmd\":"
187         cat "$outfile" || true
188     fi
189 }
190
191 _run_onnode ()
192 {
193         local thing="$1"
194         shift
195
196         local options nodespec
197
198         while : ; do
199                 case "$1" in
200                 -*)
201                         options="${options}${options:+ }${1}"
202                         shift
203                         ;;
204                 *)
205                         nodespec="$1"
206                         shift
207                         break
208                 esac
209         done
210
211         # shellcheck disable=SC2086
212         # $options can be multi-word
213         try_command_on_node $options "$nodespec" "${thing} $*"
214 }
215
216 ctdb_onnode ()
217 {
218         _run_onnode "$CTDB" "$@"
219 }
220
221 testprog_onnode ()
222 {
223         _run_onnode "${CTDB_TEST_WRAPPER} ${VALGRIND}" "$@"
224 }
225
226 function_onnode ()
227 {
228         _run_onnode "${CTDB_TEST_WRAPPER}" "$@"
229 }
230
231 sanity_check_output ()
232 {
233     local min_lines="$1"
234     local regexp="$2" # Should be anchored as necessary.
235
236     local ret=0
237
238     local num_lines
239     num_lines=$(wc -l <"$outfile" | tr -d '[:space:]')
240     echo "There are $num_lines lines of output"
241     if [ "$num_lines" -lt "$min_lines" ] ; then
242         ctdb_test_fail "BAD: that's less than the required number (${min_lines})"
243     fi
244
245     local status=0
246     local unexpected # local doesn't pass through status of command on RHS.
247     unexpected=$(grep -Ev "$regexp" "$outfile") || status=$?
248
249     # Note that this is reversed.
250     if [ $status -eq 0 ] ; then
251         echo "BAD: unexpected lines in output:"
252         echo "$unexpected" | cat -A
253         ret=1
254     else
255         echo "Output lines look OK"
256     fi
257
258     return $ret
259 }
260
261 select_test_node ()
262 {
263         try_command_on_node any ctdb pnn || return 1
264
265         test_node="$out"
266         echo "Selected node ${test_node}"
267 }
268
269 # This returns a list of "ip node" lines in $outfile
270 all_ips_on_node()
271 {
272     local node="$1"
273     try_command_on_node "$node" \
274         "$CTDB ip -X | awk -F'|' 'NR > 1 { print \$2, \$3 }'"
275 }
276
277 _select_test_node_and_ips ()
278 {
279     try_command_on_node any \
280         "$CTDB ip -X all | awk -F'|' 'NR > 1 { print \$2, \$3 }'"
281
282     test_node=""  # this matches no PNN
283     test_node_ips=""
284     local ip pnn
285     while read -r ip pnn ; do
286         if [ -z "$test_node" ] && [ "$pnn" != "-1" ] ; then
287             test_node="$pnn"
288         fi
289         if [ "$pnn" = "$test_node" ] ; then
290             test_node_ips="${test_node_ips}${test_node_ips:+ }${ip}"
291         fi
292     done <"$outfile"
293
294     echo "Selected node ${test_node} with IPs: ${test_node_ips}."
295     test_ip="${test_node_ips%% *}"
296
297     # test_prefix used by caller
298     # shellcheck disable=SC2034
299     case "$test_ip" in
300         *:*) test_prefix="${test_ip}/128" ;;
301         *)   test_prefix="${test_ip}/32"  ;;
302     esac
303
304     [ -n "$test_node" ] || return 1
305 }
306
307 select_test_node_and_ips ()
308 {
309     local timeout=10
310     while ! _select_test_node_and_ips ; do
311         echo "Unable to find a test node with IPs assigned"
312         if [ $timeout -le 0 ] ; then
313             ctdb_test_error "BAD: Too many attempts"
314             return 1
315         fi
316         sleep_for 1
317         timeout=$((timeout - 1))
318     done
319
320     return 0
321 }
322
323 # Sets: mask, iface
324 get_test_ip_mask_and_iface ()
325 {
326     # Find the interface
327     ctdb_onnode "$test_node" "ip -v -X"
328     iface=$(awk -F'|' -v ip="$test_ip" '$2 == ip { print $4 }' "$outfile")
329
330     if ctdb_test_on_cluster ; then
331         # Find the netmask
332         try_command_on_node "$test_node" ip addr show to "$test_ip"
333         mask="${out##*/}"
334         mask="${mask%% *}"
335     else
336         mask="24"
337     fi
338
339     echo "$test_ip/$mask is on $iface"
340 }
341
342 ctdb_get_all_pnns ()
343 {
344     try_command_on_node -q all "$CTDB pnn"
345     all_pnns="$out"
346 }
347
348 # The subtlety is that "ctdb delip" will fail if the IP address isn't
349 # configured on a node...
350 delete_ip_from_all_nodes ()
351 {
352     _ip="$1"
353
354     ctdb_get_all_pnns
355
356     _nodes=""
357
358     for _pnn in $all_pnns ; do
359         all_ips_on_node "$_pnn"
360         while read -r _i _ ; do
361             if [ "$_ip" = "$_i" ] ; then
362                 _nodes="${_nodes}${_nodes:+,}${_pnn}"
363             fi
364         done <"$outfile"
365     done
366
367     try_command_on_node -pq "$_nodes" "$CTDB delip $_ip"
368 }
369
370 #######################################
371
372 sleep_for ()
373 {
374     echo -n "=${1}|"
375     for i in $(seq 1 "$1") ; do
376         echo -n '.'
377         sleep 1
378     done
379     echo '|'
380 }
381
382 _cluster_is_healthy ()
383 {
384     $CTDB nodestatus all >/dev/null
385 }
386
387 _cluster_is_recovered ()
388 {
389     node_has_status 0 recovered
390 }
391
392 _cluster_is_ready ()
393 {
394     _cluster_is_healthy && _cluster_is_recovered
395 }
396
397 cluster_is_healthy ()
398 {
399         if onnode 0 "$CTDB_TEST_WRAPPER" _cluster_is_healthy ; then
400                 echo "Cluster is HEALTHY"
401                 if ! onnode 0 "$CTDB_TEST_WRAPPER" _cluster_is_recovered ; then
402                         echo "WARNING: cluster in recovery mode!"
403                 fi
404                 return 0
405         fi
406
407         echo "Cluster is UNHEALTHY"
408
409         echo "DEBUG AT $(date '+%F %T'):"
410         local i
411         for i in "onnode -q 0 $CTDB status" \
412                          "onnode -q 0 onnode all $CTDB scriptstatus" ; do
413                 echo "$i"
414                 $i || true
415         done
416
417         return 1
418 }
419
420 wait_until_ready ()
421 {
422     local timeout="${1:-120}"
423
424     echo "Waiting for cluster to become ready..."
425
426     wait_until "$timeout" onnode -q any "$CTDB_TEST_WRAPPER" _cluster_is_ready
427 }
428
429 # This function is becoming nicely overloaded.  Soon it will collapse!  :-)
430 node_has_status ()
431 {
432         local pnn="$1"
433         local status="$2"
434
435         case "$status" in
436         recovered)
437                 ! $CTDB status -n "$pnn" | \
438                         grep -Eq '^Recovery mode:RECOVERY \(1\)$'
439                 return
440                 ;;
441         notlmaster)
442                 ! $CTDB status | grep -Eq "^hash:.* lmaster:${pnn}\$"
443                 return
444                 ;;
445         esac
446
447         local bits
448         case "$status" in
449         unhealthy)    bits="?|?|?|1|*" ;;
450         healthy)      bits="?|?|?|0|*" ;;
451         disconnected) bits="1|*" ;;
452         connected)    bits="0|*" ;;
453         banned)       bits="?|1|*" ;;
454         unbanned)     bits="?|0|*" ;;
455         disabled)     bits="?|?|1|*" ;;
456         enabled)      bits="?|?|0|*" ;;
457         stopped)      bits="?|?|?|?|1|*" ;;
458         notstopped)   bits="?|?|?|?|0|*" ;;
459         *)
460                 echo "node_has_status: unknown status \"$status\""
461                 return 1
462         esac
463         local out _ line
464
465         out=$($CTDB -X status 2>&1) || return 1
466
467         {
468                 read -r _
469                 while read -r line ; do
470                         # This needs to be done in 2 steps to
471                         # avoid false matches.
472                         local line_bits="${line#|${pnn}|*|}"
473                         [ "$line_bits" = "$line" ] && continue
474                         [ "${line_bits#${bits}}" != "$line_bits" ] && \
475                                 return 0
476                 done
477                 return 1
478         } <<<"$out" # Yay bash!
479 }
480
481 wait_until_node_has_status ()
482 {
483     local pnn="$1"
484     local status="$2"
485     local timeout="${3:-30}"
486     local proxy_pnn="${4:-any}"
487
488     echo "Waiting until node $pnn has status \"$status\"..."
489
490     if ! wait_until "$timeout" onnode "$proxy_pnn" \
491          "$CTDB_TEST_WRAPPER" node_has_status "$pnn" "$status" ; then
492
493         for i in "onnode -q any $CTDB status" "onnode -q any onnode all $CTDB scriptstatus" ; do
494             echo "$i"
495             $i || true
496         done
497
498         return 1
499     fi
500
501 }
502
503 # Useful for superficially testing IP failover.
504 # IPs must be on the given node.
505 # If the first argument is '!' then the IPs must not be on the given node.
506 ips_are_on_node ()
507 {
508     local negating=false
509     if [ "$1" = "!" ] ; then
510         negating=true ; shift
511     fi
512     local node="$1" ; shift
513     local ips="$*"
514
515     local out
516
517     all_ips_on_node "$node"
518
519     local check
520     for check in $ips ; do
521         local ip pnn
522         while read -r ip pnn ; do
523             if [ "$check" = "$ip" ] ; then
524                 if [ "$pnn" = "$node" ] ; then
525                     if $negating ; then return 1 ; fi
526                 else
527                     if ! $negating ; then return 1 ; fi
528                 fi
529                 ips="${ips/${ip}}" # Remove from list
530                 break
531             fi
532             # If we're negating and we didn't see the address then it
533             # isn't hosted by anyone!
534             if $negating ; then
535                 ips="${ips/${check}}"
536             fi
537         done <"$outfile"
538     done
539
540     ips="${ips// }" # Remove any spaces.
541     [ -z "$ips" ]
542 }
543
544 wait_until_ips_are_on_node ()
545 {
546     # Go to some trouble to print a use description of what is happening
547     local not=""
548     if [ "$1" == "!" ] ; then
549         not="no longer "
550     fi
551     local node=""
552     local ips=""
553     local i
554     for i ; do
555         [ "$i" != "!" ] || continue
556         if [ -z "$node" ] ; then
557             node="$i"
558             continue
559         fi
560         ips="${ips}${ips:+, }${i}"
561     done
562     echo "Waiting for ${ips} to ${not}be assigned to node ${node}"
563
564     wait_until 60 ips_are_on_node "$@"
565 }
566
567 node_has_some_ips ()
568 {
569     local node="$1"
570
571     local out
572
573     all_ips_on_node "$node"
574
575     while read -r ip pnn ; do
576         if [ "$node" = "$pnn" ] ; then
577             return 0
578         fi
579     done <"$outfile"
580
581     return 1
582 }
583
584 wait_until_node_has_some_ips ()
585 {
586     echo "Waiting for some IPs to be assigned to node ${test_node}"
587
588     wait_until 60 node_has_some_ips "$@"
589 }
590
591 wait_until_node_has_no_ips ()
592 {
593     echo "Waiting until no IPs are assigned to node ${test_node}"
594
595     wait_until 60 ! node_has_some_ips "$@"
596 }
597
598 #######################################
599
600 ctdb_init ()
601 {
602         if ! ctdb_nodes_start ; then
603                 echo "Cluster start failed"
604                 return 1
605         fi
606
607         if ! wait_until_ready 120 ; then
608                 echo "Cluster didn't become ready"
609                 return 1
610         fi
611
612         echo "Setting RerecoveryTimeout to 1"
613         onnode -pq all "$CTDB setvar RerecoveryTimeout 1"
614
615         echo "Forcing a recovery..."
616         onnode -q 0 "$CTDB recover"
617         sleep_for 2
618
619         if ! onnode -q all "$CTDB_TEST_WRAPPER _cluster_is_recovered" ; then
620                 echo "Cluster has gone into recovery again, waiting..."
621                 if ! wait_until 30/2 onnode -q all \
622                      "$CTDB_TEST_WRAPPER _cluster_is_recovered" ; then
623                         echo "Cluster did not come out of recovery"
624                         return 1
625                 fi
626         fi
627
628         if ! onnode 0 "$CTDB_TEST_WRAPPER _cluster_is_healthy" ; then
629                 echo "Cluster became UNHEALTHY again [$(date)]"
630                 return 1
631         fi
632
633         echo "Doing a sync..."
634         onnode -q 0 "$CTDB sync"
635
636         echo "ctdb is ready"
637         return 0
638 }
639
640 ctdb_base_show ()
641 {
642         echo "${CTDB_BASE:-${CTDB_SCRIPTS_BASE}}"
643 }
644
645 #######################################
646
647 wait_for_monitor_event ()
648 {
649     local pnn="$1"
650     local timeout=120
651
652     echo "Waiting for a monitor event on node ${pnn}..."
653
654     ctdb_onnode "$pnn" scriptstatus || {
655         echo "Unable to get scriptstatus from node $pnn"
656         return 1
657     }
658
659     mv "$outfile" "${outfile}.orig"
660
661     wait_until 120 _ctdb_scriptstatus_changed
662 }
663
664 _ctdb_scriptstatus_changed ()
665 {
666     ctdb_onnode "$pnn" scriptstatus || {
667         echo "Unable to get scriptstatus from node $pnn"
668         return 1
669     }
670
671     ! diff "$outfile" "${outfile}.orig" >/dev/null
672 }
673
674 #######################################
675
676 # If the given IP is hosted then print 2 items: maskbits and iface
677 ip_maskbits_iface ()
678 {
679     _addr="$1"
680
681     case "$_addr" in
682         *:*) _family="inet6" ; _bits=128 ;;
683         *)   _family="inet"  ; _bits=32  ;;
684     esac
685
686     # Literal backslashes in awk script
687     # shellcheck disable=SC1004
688     ip addr show to "${_addr}/${_bits}" 2>/dev/null | \
689         awk -v family="${_family}" \
690             'NR == 1 { iface = $2; sub(":$", "", iface) } \
691              $1 ~ /inet/ { mask = $2; sub(".*/", "", mask); \
692                            print mask, iface, family }'
693 }
694
695 drop_ip ()
696 {
697     _addr="${1%/*}"  # Remove optional maskbits
698
699     # Intentional word splitting
700     # shellcheck disable=SC2046,SC2086
701     set -- $(ip_maskbits_iface $_addr)
702     if [ -n "$1" ] ; then
703         _maskbits="$1"
704         _iface="$2"
705         echo "Removing public address $_addr/$_maskbits from device $_iface"
706         ip addr del "$_ip/$_maskbits" dev "$_iface" >/dev/null 2>&1 || true
707     fi
708 }
709
710 drop_ips ()
711 {
712     for _ip ; do
713         drop_ip "$_ip"
714     done
715 }
716
717 #######################################
718
719 # $1: pnn, $2: DB name
720 db_get_path ()
721 {
722         ctdb_onnode -v "$1" "getdbstatus $2" | sed -n -e "s@^path: @@p"
723 }
724
725 # $1: pnn, $2: DB name
726 db_ctdb_cattdb_count_records ()
727 {
728         # Count the number of keys, excluding any that begin with '_'.
729         # This excludes at least the sequence number record in
730         # persistent/replicated databases.  The trailing "|| :" forces
731         # the command to succeed when no records are matched.
732         ctdb_onnode "$1" "cattdb $2 | grep -c '^key([0-9][0-9]*) = \"[^_]' || :"
733         echo "$out"
734 }
735
736 # $1: pnn, $2: DB name, $3: key string, $4: value string, $5: RSN (default 7)
737 db_ctdb_tstore ()
738 {
739     _tdb=$(db_get_path "$1" "$2")
740     _rsn="${5:-7}"
741     ctdb_onnode "$1" tstore "$_tdb" "$3" "$4" "$_rsn"
742 }
743
744 # $1: pnn, $2: DB name, $3: dbseqnum (must be < 255!!!!!)
745 db_ctdb_tstore_dbseqnum ()
746 {
747     # "__db_sequence_number__" + trailing 0x00
748     _key='0x5f5f64625f73657175656e63655f6e756d6265725f5f00'
749
750     # Construct 8 byte (unit64_t) database sequence number.  This
751     # probably breaks if $3 > 255
752     _value=$(printf "0x%02x%014x" "$3" 0)
753
754     db_ctdb_tstore "$1" "$2" "$_key" "$_value"
755 }
756
757 ########################################
758
759 # Make sure that $CTDB is set.
760 if [ -z "$CTDB" ] ; then
761         CTDB="ctdb"
762 fi
763
764 if ctdb_test_on_cluster ; then
765         . "${TEST_SCRIPTS_DIR}/integration_real_cluster.bash"
766 else
767         . "${TEST_SCRIPTS_DIR}/integration_local_daemons.bash"
768 fi
769
770
771 local="${CTDB_TEST_SUITE_DIR}/scripts/local.bash"
772 if [ -r "$local" ] ; then
773     . "$local"
774 fi