lustre/tests/lustre-rsync-test.sh

   1 #!/bin/bash
   2 #
   3 # Run select tests by setting ONLY, or as arguments to the script.
   4 # Skip specific tests by setting EXCEPT.
   5 #
   6 set -e
   7
   8 ONLY=${ONLY:-"$*"}
   9
  10 KILL=/bin/kill
  11 LREPL_LOG=$TMP/lustre_rsync.log
  12 ORIG_PWD=${PWD}
  13
  14 LUSTRE=${LUSTRE:-$(dirname $0)/..}
  15 . $LUSTRE/tests/test-framework.sh
  16 init_test_env "$@"
  17 init_logging
  18
  19 ALWAYS_EXCEPT="$LRSYNC_EXCEPT "
  20 always_except LU-4256   2b
  21 [[ $(uname -r) = *"debug" ]] &&
  22         always_except LU-16489  2c
  23
  24 build_test_filter
  25
  26 [ -n "$FILESET" ] && skip "Not functional for FILESET set"
  27
  28 check_and_setup_lustre
  29
  30 DIR=${DIR:-$MOUNT}
  31 assert_DIR
  32
  33 if getent group nobody; then
  34         GROUP=nobody
  35 elif getent group nogroup; then
  36         GROUP=nogroup
  37 else
  38         error "No generic nobody group"
  39 fi
  40
  41 export LRSYNC=${LRSYNC:-"$LUSTRE/utils/lustre_rsync"}
  42 [ ! -f "$LRSYNC" ] && export LRSYNC=$(which lustre_rsync)
  43 export LRSYNC="$LRSYNC -v -c no -d 2"
  44
  45 # Number of seconds to run dbench
  46 DBENCH_TIME=${DBENCH_TIME:-60}
  47 TGT=$TMP/target
  48 TGT2=$TMP/target2
  49 MDT0=$($LCTL get_param -n mdc.*.mds_server_uuid |
  50         awk '{ gsub(/_UUID/,""); print $1 }' | head -n1)
  51
  52 init_changelog() {
  53         changelog_register || error "changelog_register failed"
  54         CL_USER=(${CL_USERS[$SINGLEMDS]})
  55         echo $MDT0: Registered changelog user $CL_USER
  56         [ -z $CL_USER ] &&
  57                 echo "No changelog users present on $SINGLEMDS"
  58 }
  59
  60 fini_changelog() {
  61         changelog_clear
  62         changelog_deregister
  63 }
  64
  65 init_src() {
  66         rm -rf $TGT/$tdir $TGT/d*.lustre-rsync-test 2> /dev/null
  67         rm -rf $TGT2/$tdir $TGT2/d*.lustre-rsync-test 2> /dev/null
  68         rm -rf ${DIR}/$tdir $DIR/d*.lustre-rsync-test ${DIR}/tgt 2> /dev/null
  69         rm -f $LREPL_LOG
  70
  71         mkdir_on_mdt0 $DIR/$tdir || error "Failed to create target: " $DIR/$tdir
  72         mkdir -p ${TGT}/$tdir || error "Failed to create target: " $TGT/$tdir
  73         mkdir -p ${TGT2}/$tdir || error "Failed to create target: " $TGT2/$tdir
  74 }
  75
  76 cleanup_src_tgt() {
  77         [ ! -d $TGT2/$tdir ] || rm -rf $TGT2/$tdir # /tmp/target2/...
  78         [ ! -d $TGT/$tdir ] || rm -rf $TGT/$tdir # /tmp/target/...
  79         rm -rf $DIR/$tdir  # /mnt/lustre/...
  80         rm -rf $DIR/tgt    # /mnt/lustre/tgt
  81 }
  82
  83 # Check whether the filesystem supports xattr or not.
  84 # Return value:
  85 # "large" - large xattr is supported
  86 # "small" - large xattr is unsupported but small xattr is supported
  87 # "no"    - xattr is unsupported
  88 check_xattr() {
  89         local tgt=$1
  90         local xattr="no"
  91
  92         touch $tgt
  93
  94         local val="$(generate_string $(max_xattr_size))"
  95
  96         if large_xattr_enabled &&
  97                 setfattr -n user.foo -v $val $tgt 2>/dev/null; then
  98                 xattr="large"
  99         else
 100                 setfattr -n user.foo -v bar $tgt 2>/dev/null && xattr="small"
 101         fi
 102
 103         rm -f $tgt
 104         echo $xattr
 105 }
 106
 107 check_diff() {
 108         local changelog_file=$(generate_logname "changelog")
 109
 110         if [ -e $1 -o -e $2 ]; then
 111                 diff -rq -x "dev1" $1 $2
 112                 local RC=$?
 113                 if [ $RC -ne 0 ]; then
 114                         $LFS changelog $MDT0 > $changelog_file
 115                         error "Failure in replication; differences found."
 116                 fi
 117         fi
 118 }
 119
 120 procs_are_stopped() {
 121         local pids="$*"
 122         local state
 123
 124         for state in $(ps -p "$pids" -o state=); do
 125                 if [[ "$state" != T ]]; then
 126                         return 1
 127                 fi
 128         done
 129
 130         return 0
 131 }
 132
 133 # Send SIGSTOP to PIDs and wait up to 60 seconds for them to show a
 134 # stopped process state.
 135 stop_procs() {
 136         local pids="$*"
 137         local end
 138
 139         $KILL -SIGSTOP $pids
 140         end=$((SECONDS + 60))
 141         while ((SECONDS < end)); do
 142                 if procs_are_stopped $pids; then
 143                         return 0
 144                 fi
 145
 146                 sleep 1
 147         done
 148
 149         return 1
 150 }
 151
 152 # Test 1A - test basic operations
 153 test_1A() { # was test_1
 154         init_src
 155         init_changelog
 156         local xattr=$(check_xattr $TGT/foo)
 157
 158         # Directory create
 159         mkdir $DIR/$tdir/d1
 160         mkdir $DIR/$tdir/d2
 161
 162         # File create
 163         touch $DIR/$tdir/file1
 164         cp /etc/hosts  $DIR/$tdir/d1/
 165         touch $DIR/$tdir/d1/"space in filename"
 166         touch $DIR/$tdir/d1/file2
 167
 168         # File rename
 169         mv $DIR/$tdir/d1/file2 $DIR/$tdir/d2/file3
 170
 171         # File and directory delete
 172         touch $DIR/$tdir/d1/file4
 173         mkdir $DIR/$tdir/d1/del
 174         touch $DIR/$tdir/d1/del/del1
 175         touch $DIR/$tdir/d1/del/del2
 176         rm -rf $DIR/$tdir/d1/del
 177         rm $DIR/$tdir/d1/file4
 178
 179         # Hard and soft links
 180         cat /etc/hosts > $DIR/$tdir/d1/link1
 181         ln $DIR/$tdir/d1/link1  $DIR/$tdir/d1/link2
 182         ln -s $DIR/$tdir/d1/link1  $DIR/$tdir/d1/link3
 183
 184         # Device files
 185         #mknod $DIR/$tdir/dev1 b 8 1
 186
 187         # Replicate
 188         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 189         echo "Replication #1"
 190         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 191                 -D $LRSYNC_LOG
 192
 193         # Set attributes
 194         chmod 000 $DIR/$tdir/d2/file3
 195         chown nobody:$GROUP $DIR/$tdir/d2/file3
 196
 197         # Set xattrs
 198         if [[ "$xattr" != "no" ]]; then
 199                 local value
 200                 touch $DIR/$tdir/file5
 201                 [[ "$xattr" = "large" ]] &&
 202                         value="$(generate_string $(max_xattr_size))" || value="bar"
 203                 setfattr -n user.foo -v $value $DIR/$tdir/file5 ||
 204                         error "setfattr failed"
 205         fi
 206
 207         echo "Replication #2"
 208         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 209
 210         if [[ "$xattr" != "no" ]]; then
 211                 local xval1=$(get_xattr_value user.foo $TGT/$tdir/file5)
 212                 local xval2=$(get_xattr_value user.foo $TGT2/$tdir/file5)
 213
 214                 if [[ "$xval1" != "$value" || "$xval2" != "$value" ]]; then
 215                         error "Error in replicating xattrs."
 216                 fi
 217         fi
 218
 219         # Use diff to compare the source and the destination
 220         check_diff $DIR/$tdir $TGT/$tdir
 221         check_diff $DIR/$tdir $TGT2/$tdir
 222
 223         fini_changelog
 224         cleanup_src_tgt
 225 }
 226 run_test 1A "Simple Replication"
 227
 228 # Test 1a - test create/delete operations in ROOT directory
 229 test_1a() { # LU-5005
 230         rm -rf $TGT/root-* 2> /dev/null
 231         rm -rf $DIR/root-* 2> /dev/null
 232         init_src
 233         init_changelog
 234
 235         # Directory create
 236         mkdir_on_mdt0 $DIR/root-dir
 237
 238         # File create
 239         touch $DIR/root-file
 240         touch $DIR/root-file2
 241
 242         # File rename
 243         mv $DIR/root-file2 $DIR/root-file3
 244
 245         # File and directory delete
 246         touch $DIR/root-file4
 247         mkdir_on_mdt0 $DIR/root-dir1
 248         rm $DIR/root-file4
 249         rm -rf $DIR/root-dir1
 250
 251         # Replicate
 252         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 253         echo "Replication"
 254         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 255                 -D $LRSYNC_LOG
 256
 257         # Verify
 258         stat $TGT/root-dir || error "Dir create not replicated"
 259         stat $TGT/root-file || error "File create not replicated"
 260         stat $TGT/root-file2 && error "Rename not replicated (src)"
 261         stat $TGT/root-file3 || error "Rename not replicated (tgt)"
 262         stat $TGT/root-dir1 && error "Dir delete not replicated"
 263         stat $TGT/root-file4 && error "File delete not replicated"
 264
 265         cleanup_src_tgt
 266         fini_changelog
 267         rm -fr $TGT/root-*
 268         rm -fr $DIR/root-*
 269         return 0
 270 }
 271 run_test 1a "Replicate create/delete operations in ROOT directory"
 272
 273 # Test 2a - Replicate files created by dbench
 274 test_2a() {
 275         init_src
 276         init_changelog
 277
 278         # Run dbench
 279         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME ||
 280                 error "dbench failed to complete $DBENCH_TIME seconds"
 281
 282         local log=$(generate_logname "lrsync_log")
 283         # Replicate the changes to $TGT
 284         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG -D $log
 285
 286         # Use diff to compare the source and the destination
 287         check_diff $DIR/$tdir $TGT/$tdir
 288
 289         fini_changelog
 290         cleanup_src_tgt
 291         return 0
 292 }
 293 run_test 2a "Replicate files created by dbench."
 294
 295 # Test 2b - Replicate files changed by dbench.
 296 test_2b() {
 297         local child_pid
 298         init_src
 299         init_changelog
 300
 301         # Run dbench
 302         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME &
 303         # wait for dbench to start
 304         wait_for_function 'child_pid=$(pgrep dbench)' 360
 305         # let dbench run for a bit
 306         sleep 10
 307
 308         echo PIDs: $child_pid
 309         echo Stopping dbench
 310         stop_procs $child_pid
 311
 312         local log=$(generate_logname "lrsync_log")
 313         echo Starting replication
 314         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG -D $log
 315         check_diff $DIR/$tdir $TGT/$tdir
 316
 317         echo Resuming dbench
 318         $KILL -SIGCONT $child_pid
 319         sleep 10
 320
 321         echo Stopping dbench
 322         stop_procs $child_pid
 323
 324         echo Starting replication
 325         $LRSYNC -l $LREPL_LOG -D $log
 326         check_diff $DIR/$tdir $TGT/$tdir
 327
 328         echo "Wait for dbench to finish"
 329         $KILL -SIGCONT $child_pid
 330         wait
 331
 332         # Replicate the changes to $TGT
 333         echo Starting replication
 334         $LRSYNC -l $LREPL_LOG -D $log
 335
 336         check_diff $DIR/$tdir $TGT/$tdir
 337
 338         fini_changelog
 339         cleanup_src_tgt
 340         return 0
 341 }
 342 run_test 2b "Replicate files changed by dbench."
 343
 344 # Test 2c - Replicate files while dbench is running
 345 test_2c() {
 346         init_src
 347         init_changelog
 348
 349         # Run dbench
 350         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME &
 351
 352         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 353         # Replicate the changes to $TGT
 354         sleep 10 # give dbench a headstart
 355         local quit=0
 356         while [ $quit -le 1 ];
 357         do
 358                 echo "Running lustre_rsync"
 359                 $LRSYNC -s $DIR -t $TGT -t $TGT2 -m ${mds1_svc} -u $CL_USER \
 360                         -l $LREPL_LOG -D $LRSYNC_LOG
 361                 sleep 5
 362                 pgrep dbench
 363                 if [ $? -ne 0 ]; then
 364                         quit=$(expr $quit + 1)
 365                 fi
 366         done
 367
 368         # Use diff to compare the source and the destination
 369         check_diff $DIR/$tdir $TGT/$tdir
 370         check_diff $DIR/$tdir $TGT2/$tdir
 371
 372         fini_changelog
 373         cleanup_src_tgt
 374         return 0
 375 }
 376 run_test 2c "Replicate files while dbench is running."
 377
 378 # Test 3a - Replicate files created by createmany
 379 test_3a() {
 380         init_src
 381         init_changelog
 382
 383         local numfiles=1000
 384         createmany -o $DIR/$tdir/$tfile $numfiles || error "createmany failed"
 385
 386         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 387         # Replicate the changes to $TGT
 388         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 389                 -D $LRSYNC_LOG
 390         check_diff $DIR/$tdir $TGT/$tdir
 391         check_diff $DIR/$tdir $TGT2/$tdir
 392
 393         fini_changelog
 394         cleanup_src_tgt
 395         return 0
 396 }
 397 run_test 3a "Replicate files created by createmany"
 398
 399 # Test 3b - Replicate files created by writemany
 400 test_3b() {
 401         init_src
 402         init_changelog
 403
 404         local time=60
 405         local threads=5
 406         writemany -q -a $DIR/$tdir/$tfile $time $threads ||
 407                 error "writemany failed"
 408
 409         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 410         # Replicate the changes to $TGT
 411         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 412                 -D $LRSYNC_LOG
 413
 414         check_diff $DIR/$tdir $TGT/$tdir
 415         check_diff $DIR/$tdir $TGT2/$tdir
 416
 417         fini_changelog
 418         cleanup_src_tgt
 419         return 0
 420 }
 421 run_test 3b "Replicate files created by writemany"
 422
 423 # Test 3c - Replicate files created by createmany/unlinkmany
 424 test_3c() {
 425         init_src
 426         init_changelog
 427
 428         local numfiles=1000
 429         createmany -o $DIR/$tdir/$tfile $numfiles || error "createmany failed"
 430         unlinkmany $DIR/$tdir/$tfile $numfiles || error "unlinkmany failed"
 431
 432         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 433         # Replicate the changes to $TGT
 434         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0  -u $CL_USER -l $LREPL_LOG \
 435                 -D $LRSYNC_LOG
 436         check_diff $DIR/$tdir $TGT/$tdir
 437         check_diff $DIR/$tdir $TGT2/$tdir
 438
 439         fini_changelog
 440         cleanup_src_tgt
 441         return 0
 442 }
 443 run_test 3c "Replicate files created by createmany/unlinkmany"
 444
 445 # Test 4 - Replicate files created by iozone
 446 test_4() {
 447         which iozone > /dev/null 2>&1
 448         [ $? -ne 0 ] && skip "iozone not found"
 449
 450         init_src
 451         init_changelog
 452
 453         END_RUN_FILE=${DIR}/$tdir/run LOAD_PID_FILE=${DIR}/$tdir/pid \
 454                 MOUNT=${DIR}/$tdir RECOVERY_SCALE_ENABLE_REMOTE_DIRS=false \
 455                 RECOVERY_SCALE_ENABLE_STRIPED_DIRS=false run_iozone.sh &
 456         sleep 30
 457         child_pid=$(pgrep iozone)
 458         stop_procs $child_pid
 459
 460         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 461         # Replicate the changes to $TGT
 462         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0  -u $CL_USER -l $LREPL_LOG \
 463                 -D $LRSYNC_LOG
 464         check_diff $DIR/$tdir $TGT/$tdir
 465         check_diff $DIR/$tdir $TGT2/$tdir
 466
 467         $KILL -SIGCONT $child_pid
 468         sleep 60
 469         $KILL -SIGKILL $(pgrep run_iozone.sh)
 470         $KILL -SIGKILL $(pgrep iozone)
 471
 472         # After killing 'run_iozone.sh', process 'iozone' becomes the
 473         # child of PID 1. Hence 'wait' does not wait for it. Killing
 474         # iozone first, means more iozone processes are spawned off which
 475         # is not desirable. So, after sending a sigkill, the test goes
 476         # into a wait loop for iozone to cleanup and exit.
 477         wait
 478         while [ "$(pgrep "iozone")" != "" ];
 479         do
 480                 ps -ef | grep iozone | grep -v grep
 481                 sleep 1;
 482         done
 483
 484         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 485         check_diff $DIR/$tdir $TGT/$tdir
 486         check_diff $DIR/$tdir $TGT2/$tdir
 487
 488         fini_changelog
 489         cleanup_src_tgt
 490         return 0
 491 }
 492 run_test 4 "Replicate files created by iozone"
 493
 494 # Test 5a - Stop / start lustre_rsync
 495 test_5a() {
 496         init_src
 497         init_changelog
 498
 499         NUMTEST=2000
 500         createmany -o $DIR/$tdir/$tfile $NUMTEST
 501
 502         # Replicate the changes to $TGT
 503         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 504         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 505                 -D $LRSYNC_LOG &
 506         local child_pid=$!
 507         sleep 30
 508         $KILL -SIGHUP $child_pid
 509         wait
 510         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 511
 512         check_diff $DIR/$tdir $TGT/$tdir
 513         check_diff $DIR/$tdir $TGT2/$tdir
 514
 515         fini_changelog
 516         cleanup_src_tgt
 517         return 0
 518 }
 519 run_test 5a "Stop / start lustre_rsync"
 520
 521 # Test 5b - Kill / restart lustre_rsync
 522 test_5b() {
 523         init_src
 524         init_changelog
 525
 526         NUMTEST=2000
 527         createmany -o $DIR/$tdir/$tfile $NUMTEST
 528
 529         # Replicate the changes to $TGT
 530         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 531         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 532                 -D $LRSYNC_LOG &
 533         local child_pid=$!
 534         sleep 30
 535         $KILL -SIGKILL $child_pid
 536         wait
 537         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 538
 539         check_diff $DIR/$tdir $TGT/$tdir
 540         check_diff $DIR/$tdir $TGT2/$tdir
 541
 542         fini_changelog
 543         cleanup_src_tgt
 544         return 0
 545 }
 546 run_test 5b "Kill / restart lustre_rsync"
 547
 548 # Test 6 - lustre_rsync large no of hard links
 549 test_6() {
 550         init_src
 551         init_changelog
 552
 553         local num_links=128
 554         local i
 555
 556         touch $DIR/$tdir/link0
 557         for ((i = 1; i < num_links - 1; i++)); do
 558                 ln $DIR/$tdir/link0 $DIR/$tdir/link$i
 559         done
 560         # create an extra hard link of src name ending with dest name
 561         ln $DIR/$tdir/link0 $DIR/$tdir/ink0
 562
 563         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 564         # Replicate the changes to $TGT
 565         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 566                 -D $LRSYNC_LOG
 567         check_diff $DIR/$tdir $TGT/$tdir
 568         check_diff $DIR/$tdir $TGT2/$tdir
 569
 570         local count1=$(stat --format=%h $TGT/$tdir/link0)
 571         local count2=$(stat --format=%h $TGT2/$tdir/link0)
 572         if ((count1 != num_links || count2 != num_links)); then
 573                 ls -l $TGT/$tdir/link0 $TGT2/$tdir/link0
 574                 error "Incorrect no of hard links found $count1, $count2"
 575         fi
 576
 577         fini_changelog
 578         cleanup_src_tgt
 579         return 0
 580 }
 581 run_test 6 "lustre_rsync large no of hard links"
 582
 583 # Test 7 - lustre_rsync stripesize
 584 test_7() {
 585         local numfiles=100
 586
 587         init_src
 588         mkdir -p ${DIR}/tgt/$tdir
 589         init_changelog
 590
 591         $LFS setstripe -c $OSTCOUNT $DIR/$tdir ||
 592                 error "$LFS setstripe failed"
 593         createmany -o $DIR/$tdir/$tfile $numfiles
 594
 595         # To simulate replication to another lustre filesystem, replicate
 596         # the changes to $DIR/tgt. We can't turn off the changelogs
 597         # while we are registered, so lustre_rsync better not try to
 598         # replicate the replication steps.  It seems ok :)
 599
 600         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 601         $LRSYNC -s $DIR -t $DIR/tgt -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 602                 -D $LRSYNC_LOG
 603         check_diff ${DIR}/$tdir $DIR/tgt/$tdir
 604
 605         local i=0
 606         while [ $i -lt $numfiles ];
 607         do
 608                 local count=$($LFS getstripe $DIR/tgt/$tdir/${tfile}$i |
 609                               awk '/stripe_count/ {print $2}')
 610                 if [ $count -ne $OSTCOUNT ]; then
 611                         error "Stripe size not replicated"
 612                 fi
 613                 i=$(expr $i + 1)
 614         done
 615         fini_changelog
 616         cleanup_src_tgt
 617         return 0
 618 }
 619 run_test 7 "lustre_rsync stripesize"
 620
 621 # Test 8 - Replicate multiple file/directory moves
 622 test_8() {
 623         init_src
 624         init_changelog
 625
 626         for i in 1 2 3 4 5 6 7 8 9; do
 627                 mkdir $DIR/$tdir/d$i
 628                 for j in 1 2 3 4 5 6 7 8 9; do
 629                         mkdir $DIR/$tdir/d$i/d$i$j
 630                         createmany -o $DIR/$tdir/d$i/d$i$j/a 10 \
 631                             > /dev/null
 632                         mv $DIR/$tdir/d$i/d$i$j $DIR/$tdir/d$i/d0$i$j
 633                         createmany -o $DIR/$tdir/d$i/d0$i$j/b 10 \
 634                             > /dev/null
 635                         mv $DIR/$tdir/d$i/d0$i$j/a0 $DIR/$tdir/d$i/d0$i$j/c0
 636                 done
 637                 mv $DIR/$tdir/d$i $DIR/$tdir/d0$i
 638         done
 639
 640         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 641         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 642                 -D $LRSYNC_LOG
 643
 644         check_diff ${DIR}/$tdir $TGT/$tdir
 645
 646         fini_changelog
 647         cleanup_src_tgt
 648         return 0
 649 }
 650 run_test 8 "Replicate multiple file/directory moves"
 651
 652 test_9() {
 653         init_src
 654         init_changelog
 655
 656         mkdir $DIR/$tdir/foo
 657         touch $DIR/$tdir/foo/a1
 658
 659         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 660         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 661                 -D $LRSYNC_LOG
 662
 663         check_diff ${DIR}/$tdir $TGT/$tdir
 664
 665         rm -rf $DIR/$tdir/foo
 666
 667         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 668                 -D $LRSYNC_LOG
 669
 670         check_diff ${DIR}/$tdir $TGT/$tdir
 671
 672         fini_changelog
 673         cleanup_src_tgt
 674         return 0
 675 }
 676 run_test 9 "Replicate recursive directory removal"
 677
 678 cd $ORIG_PWD
 679 complete_test $SECONDS
 680 check_and_cleanup_lustre
 681 exit_status