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 # bug number for skipped test: LU-4256
  21 ALWAYS_EXCEPT+="               2b"
  22 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  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         rm -rf $TGT/$tdir
  78         rm -rf $DIR/$tdir
  79         rm -rf $DIR/tgt
  80 }
  81
  82 # Check whether the filesystem supports xattr or not.
  83 # Return value:
  84 # "large" - large xattr is supported
  85 # "small" - large xattr is unsupported but small xattr is supported
  86 # "no"    - xattr is unsupported
  87 check_xattr() {
  88     local tgt=$1
  89     local xattr="no"
  90
  91     touch $tgt
  92
  93     local val="$(generate_string $(max_xattr_size))"
  94     if large_xattr_enabled &&
  95        setfattr -n user.foo -v $val $tgt 2>/dev/null; then
  96             xattr="large"
  97     else
  98         setfattr -n user.foo -v bar $tgt 2>/dev/null && xattr="small"
  99     fi
 100
 101     rm -f $tgt
 102     echo $xattr
 103 }
 104
 105 check_diff() {
 106         local changelog_file=$(generate_logname "changelog")
 107
 108         if [ -e $1 -o -e $2 ]; then
 109                 diff -rq -x "dev1" $1 $2
 110                 local RC=$?
 111                 if [ $RC -ne 0 ]; then
 112                         $LFS changelog $MDT0 > $changelog_file
 113                         error "Failure in replication; differences found."
 114                 fi
 115         fi
 116 }
 117
 118 procs_are_stopped() {
 119         local pids="$*"
 120         local state
 121
 122         for state in $(ps -p "$pids" -o state=); do
 123                 if [[ "$state" != T ]]; then
 124                         return 1
 125                 fi
 126         done
 127
 128         return 0
 129 }
 130
 131 # Send SIGSTOP to PIDs and wait up to 60 seconds for them to show a
 132 # stopped process state.
 133 stop_procs() {
 134         local pids="$*"
 135         local end
 136
 137         $KILL -SIGSTOP $pids
 138         end=$((SECONDS + 60))
 139         while ((SECONDS < end)); do
 140                 if procs_are_stopped $pids; then
 141                         return 0
 142                 fi
 143
 144                 sleep 1
 145         done
 146
 147         return 1
 148 }
 149
 150 # Test 1A - test basic operations
 151 test_1A() { # was test_1
 152     init_src
 153     init_changelog
 154     local xattr=$(check_xattr $TGT/foo)
 155
 156     # Directory create
 157     mkdir $DIR/$tdir/d1
 158     mkdir $DIR/$tdir/d2
 159
 160     # File create
 161     touch $DIR/$tdir/file1
 162     cp /etc/hosts  $DIR/$tdir/d1/
 163     touch  $DIR/$tdir/d1/"space in filename"
 164     touch  $DIR/$tdir/d1/file2
 165
 166     # File rename
 167     mv $DIR/$tdir/d1/file2 $DIR/$tdir/d2/file3
 168
 169     # File and directory delete
 170     touch $DIR/$tdir/d1/file4
 171     mkdir $DIR/$tdir/d1/del
 172     touch  $DIR/$tdir/d1/del/del1
 173     touch  $DIR/$tdir/d1/del/del2
 174     rm -rf $DIR/$tdir/d1/del
 175     rm $DIR/$tdir/d1/file4
 176
 177     #hard and soft links
 178     cat /etc/hosts > $DIR/$tdir/d1/link1
 179     ln  $DIR/$tdir/d1/link1  $DIR/$tdir/d1/link2
 180     ln -s $DIR/$tdir/d1/link1  $DIR/$tdir/d1/link3
 181
 182     # Device files
 183     #mknod $DIR/$tdir/dev1 b 8 1
 184
 185         # Replicate
 186         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 187         echo "Replication #1"
 188         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 189                 -D $LRSYNC_LOG
 190
 191     # Set attributes
 192     chmod 000 $DIR/$tdir/d2/file3
 193     chown nobody:$GROUP $DIR/$tdir/d2/file3
 194
 195     # Set xattrs
 196     if [[ "$xattr" != "no" ]]; then
 197         local value
 198         touch $DIR/$tdir/file5
 199         [[ "$xattr" = "large" ]] &&
 200             value="$(generate_string $(max_xattr_size))" || value="bar"
 201         setfattr -n user.foo -v $value $DIR/$tdir/file5
 202     fi
 203
 204         echo "Replication #2"
 205         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 206
 207         if [[ "$xattr" != "no" ]]; then
 208                 local xval1=$(get_xattr_value user.foo $TGT/$tdir/file5)
 209                 local xval2=$(get_xattr_value user.foo $TGT2/$tdir/file5)
 210
 211                 if [[ "$xval1" != "$value" || "$xval2" != "$value" ]]; then
 212                         error "Error in replicating xattrs."
 213                 fi
 214         fi
 215
 216         # Use diff to compare the source and the destination
 217         check_diff $DIR/$tdir $TGT/$tdir
 218         check_diff $DIR/$tdir $TGT2/$tdir
 219
 220         fini_changelog
 221         cleanup_src_tgt
 222 }
 223 run_test 1A "Simple Replication"
 224
 225 # Test 1a - test create/delete operations in ROOT directory
 226 test_1a() { # LU-5005
 227         rm -rf $TGT/root-* 2> /dev/null
 228         rm -rf $DIR/root-* 2> /dev/null
 229         init_src
 230         init_changelog
 231
 232         # Directory create
 233         mkdir_on_mdt0 $DIR/root-dir
 234
 235         # File create
 236         touch $DIR/root-file
 237         touch $DIR/root-file2
 238
 239         # File rename
 240         mv $DIR/root-file2 $DIR/root-file3
 241
 242         # File and directory delete
 243         touch $DIR/root-file4
 244         mkdir_on_mdt0 $DIR/root-dir1
 245         rm $DIR/root-file4
 246         rm -rf $DIR/root-dir1
 247
 248         # Replicate
 249         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 250         echo "Replication"
 251         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 252                 -D $LRSYNC_LOG
 253
 254         # Verify
 255         stat $TGT/root-dir || error "Dir create not replicated"
 256         stat $TGT/root-file || error "File create not replicated"
 257         stat $TGT/root-file2 && error "Rename not replicated (src)"
 258         stat $TGT/root-file3 || error "Rename not replicated (tgt)"
 259         stat $TGT/root-dir1 && error "Dir delete not replicated"
 260         stat $TGT/root-file4 && error "File delete not replicated"
 261
 262         cleanup_src_tgt
 263         fini_changelog
 264         rm -fr $TGT/root-*
 265         rm -fr $DIR/root-*
 266         return 0
 267 }
 268 run_test 1a "Replicate create/delete operations in ROOT directory"
 269
 270 # Test 2a - Replicate files created by dbench
 271 test_2a() {
 272         init_src
 273         init_changelog
 274
 275         # Run dbench
 276         sh rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME || error "dbench failed"
 277
 278         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 279         # Replicate the changes to $TGT
 280         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 281                 -D $LRSYNC_LOG
 282
 283         # Use diff to compare the source and the destination
 284         check_diff $DIR/$tdir $TGT/$tdir
 285         check_diff $DIR/$tdir $TGT2/$tdir
 286
 287         fini_changelog
 288         cleanup_src_tgt
 289         return 0
 290 }
 291 run_test 2a "Replicate files created by dbench."
 292
 293 # Test 2b - Replicate files changed by dbench.
 294 test_2b() {
 295         local child_pid
 296         init_src
 297         init_changelog
 298
 299         # Run dbench
 300         sh rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME &
 301         # wait for dbench to start
 302         wait_for_function 'child_pid=$(pgrep dbench)' 360
 303         # let dbench run for a bit
 304         sleep 10
 305
 306         echo PIDs: $child_pid
 307         echo Stopping dbench
 308         stop_procs $child_pid
 309
 310         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 311         echo Starting replication
 312         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 313                 -D $LRSYNC_LOG
 314         check_diff $DIR/$tdir $TGT/$tdir
 315
 316     echo Resuming dbench
 317     $KILL -SIGCONT $child_pid
 318     sleep 10
 319
 320     echo Stopping dbench
 321         stop_procs $child_pid
 322
 323         echo Starting replication
 324         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 325         check_diff $DIR/$tdir $TGT/$tdir
 326
 327     echo "Wait for dbench to finish"
 328     $KILL -SIGCONT $child_pid
 329     wait
 330
 331         # Replicate the changes to $TGT
 332         echo Starting replication
 333         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 334
 335         check_diff $DIR/$tdir $TGT/$tdir
 336         check_diff $DIR/$tdir $TGT2/$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         sh 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 run_iozone.sh &
 455         sleep 30
 456         child_pid=$(pgrep iozone)
 457         stop_procs $child_pid
 458
 459         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 460         # Replicate the changes to $TGT
 461         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0  -u $CL_USER -l $LREPL_LOG \
 462                 -D $LRSYNC_LOG
 463         check_diff $DIR/$tdir $TGT/$tdir
 464         check_diff $DIR/$tdir $TGT2/$tdir
 465
 466     $KILL -SIGCONT $child_pid
 467     sleep 60
 468     $KILL -SIGKILL $(pgrep run_iozone.sh)
 469     $KILL -SIGKILL $(pgrep iozone)
 470
 471     # After killing 'run_iozone.sh', process 'iozone' becomes the
 472     # child of PID 1. Hence 'wait' does not wait for it. Killing
 473     # iozone first, means more iozone processes are spawned off which
 474     # is not desirable. So, after sending a sigkill, the test goes
 475     # into a wait loop for iozone to cleanup and exit.
 476     wait
 477     while [ "$(pgrep "iozone")" != "" ];
 478     do
 479       ps -ef | grep iozone | grep -v grep
 480       sleep 1;
 481     done
 482
 483         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 484         check_diff $DIR/$tdir $TGT/$tdir
 485         check_diff $DIR/$tdir $TGT2/$tdir
 486
 487     fini_changelog
 488     cleanup_src_tgt
 489     return 0
 490 }
 491 run_test 4 "Replicate files created by iozone"
 492
 493 # Test 5a - Stop / start lustre_rsync
 494 test_5a() {
 495         init_src
 496         init_changelog
 497
 498         NUMTEST=2000
 499         createmany -o $DIR/$tdir/$tfile $NUMTEST
 500
 501         # Replicate the changes to $TGT
 502         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 503         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 504                 -D $LRSYNC_LOG &
 505         local child_pid=$!
 506         sleep 30
 507         $KILL -SIGHUP $child_pid
 508         wait
 509         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 510
 511         check_diff $DIR/$tdir $TGT/$tdir
 512         check_diff $DIR/$tdir $TGT2/$tdir
 513
 514         fini_changelog
 515         cleanup_src_tgt
 516         return 0
 517 }
 518 run_test 5a "Stop / start lustre_rsync"
 519
 520 # Test 5b - Kill / restart lustre_rsync
 521 test_5b() {
 522         init_src
 523         init_changelog
 524
 525         NUMTEST=2000
 526         createmany -o $DIR/$tdir/$tfile $NUMTEST
 527
 528         # Replicate the changes to $TGT
 529         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 530         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 531                 -D $LRSYNC_LOG &
 532         local child_pid=$!
 533         sleep 30
 534         $KILL -SIGKILL $child_pid
 535         wait
 536         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
 537
 538         check_diff $DIR/$tdir $TGT/$tdir
 539         check_diff $DIR/$tdir $TGT2/$tdir
 540
 541         fini_changelog
 542         cleanup_src_tgt
 543         return 0
 544 }
 545 run_test 5b "Kill / restart lustre_rsync"
 546
 547 # Test 6 - lustre_rsync large no of hard links
 548 test_6() {
 549         init_src
 550         init_changelog
 551
 552         local num_links=128
 553         local i
 554
 555         touch $DIR/$tdir/link0
 556         for ((i = 1; i < num_links - 1; i++)); do
 557                 ln $DIR/$tdir/link0 $DIR/$tdir/link$i
 558         done
 559         # create an extra hard link of src name ending with dest name
 560         ln $DIR/$tdir/link0 $DIR/$tdir/ink0
 561
 562         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 563         # Replicate the changes to $TGT
 564         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 565                 -D $LRSYNC_LOG
 566         check_diff $DIR/$tdir $TGT/$tdir
 567         check_diff $DIR/$tdir $TGT2/$tdir
 568
 569         local count1=$(stat --format=%h $TGT/$tdir/link0)
 570         local count2=$(stat --format=%h $TGT2/$tdir/link0)
 571         if ((count1 != num_links || count2 != num_links)); then
 572                 ls -l $TGT/$tdir/link0 $TGT2/$tdir/link0
 573                 error "Incorrect no of hard links found $count1, $count2"
 574         fi
 575
 576         fini_changelog
 577         cleanup_src_tgt
 578         return 0
 579 }
 580 run_test 6 "lustre_rsync large no of hard links"
 581
 582 # Test 7 - lustre_rsync stripesize
 583 test_7() {
 584         local numfiles=100
 585
 586         init_src
 587         mkdir -p ${DIR}/tgt/$tdir
 588         init_changelog
 589
 590         $LFS setstripe -c $OSTCOUNT $DIR/$tdir ||
 591                 error "$LFS setstripe failed"
 592         createmany -o $DIR/$tdir/$tfile $numfiles
 593
 594         # To simulate replication to another lustre filesystem, replicate
 595         # the changes to $DIR/tgt. We can't turn off the changelogs
 596         # while we are registered, so lustre_rsync better not try to
 597         # replicate the replication steps.  It seems ok :)
 598
 599         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 600         $LRSYNC -s $DIR -t $DIR/tgt -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 601                 -D $LRSYNC_LOG
 602         check_diff ${DIR}/$tdir $DIR/tgt/$tdir
 603
 604         local i=0
 605         while [ $i -lt $numfiles ];
 606         do
 607                 local count=$($LFS getstripe $DIR/tgt/$tdir/${tfile}$i |
 608                               awk '/stripe_count/ {print $2}')
 609                 if [ $count -ne $OSTCOUNT ]; then
 610                         error "Stripe size not replicated"
 611                 fi
 612                 i=$(expr $i + 1)
 613         done
 614         fini_changelog
 615         cleanup_src_tgt
 616         return 0
 617 }
 618 run_test 7 "lustre_rsync stripesize"
 619
 620 # Test 8 - Replicate multiple file/directory moves
 621 test_8() {
 622     init_src
 623     init_changelog
 624
 625     for i in 1 2 3 4 5 6 7 8 9; do
 626         mkdir $DIR/$tdir/d$i
 627             for j in 1 2 3 4 5 6 7 8 9; do
 628                 mkdir $DIR/$tdir/d$i/d$i$j
 629                 createmany -o $DIR/$tdir/d$i/d$i$j/a 10 \
 630                     > /dev/null
 631                 mv $DIR/$tdir/d$i/d$i$j $DIR/$tdir/d$i/d0$i$j
 632                 createmany -o $DIR/$tdir/d$i/d0$i$j/b 10 \
 633                     > /dev/null
 634                 mv $DIR/$tdir/d$i/d0$i$j/a0 $DIR/$tdir/d$i/d0$i$j/c0
 635             done
 636             mv $DIR/$tdir/d$i $DIR/$tdir/d0$i
 637     done
 638
 639         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 640         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 641                 -D $LRSYNC_LOG
 642
 643         check_diff ${DIR}/$tdir $TGT/$tdir
 644
 645     fini_changelog
 646     cleanup_src_tgt
 647     return 0
 648 }
 649 run_test 8 "Replicate multiple file/directory moves"
 650
 651 test_9() {
 652     init_src
 653     init_changelog
 654
 655     mkdir $DIR/$tdir/foo
 656     touch $DIR/$tdir/foo/a1
 657
 658         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 659         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 660                 -D $LRSYNC_LOG
 661
 662         check_diff ${DIR}/$tdir $TGT/$tdir
 663
 664         rm -rf $DIR/$tdir/foo
 665
 666         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 667                 -D $LRSYNC_LOG
 668
 669         check_diff ${DIR}/$tdir $TGT/$tdir
 670
 671     fini_changelog
 672     cleanup_src_tgt
 673     return 0
 674 }
 675 run_test 9 "Replicate recursive directory removal"
 676
 677 cd $ORIG_PWD
 678 complete $SECONDS
 679 check_and_cleanup_lustre
 680 exit_status