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         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME ||
 277                 error "dbench failed"
 278
 279         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 280         # Replicate the changes to $TGT
 281         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 282                 -D $LRSYNC_LOG
 283
 284         # Use diff to compare the source and the destination
 285         check_diff $DIR/$tdir $TGT/$tdir
 286         check_diff $DIR/$tdir $TGT2/$tdir
 287
 288         fini_changelog
 289         cleanup_src_tgt
 290         return 0
 291 }
 292 run_test 2a "Replicate files created by dbench."
 293
 294 # Test 2b - Replicate files changed by dbench.
 295 test_2b() {
 296         local child_pid
 297         init_src
 298         init_changelog
 299
 300         # Run dbench
 301         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME &
 302         # wait for dbench to start
 303         wait_for_function 'child_pid=$(pgrep dbench)' 360
 304         # let dbench run for a bit
 305         sleep 10
 306
 307         echo PIDs: $child_pid
 308         echo Stopping dbench
 309         stop_procs $child_pid
 310
 311         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 312         echo Starting replication
 313         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 314                 -D $LRSYNC_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 $LRSYNC_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 $LRSYNC_LOG
 335
 336         check_diff $DIR/$tdir $TGT/$tdir
 337         check_diff $DIR/$tdir $TGT2/$tdir
 338
 339     fini_changelog
 340     cleanup_src_tgt
 341     return 0
 342 }
 343 run_test 2b "Replicate files changed by dbench."
 344
 345 # Test 2c - Replicate files while dbench is running
 346 test_2c() {
 347         init_src
 348         init_changelog
 349
 350         # Run dbench
 351         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME &
 352
 353         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 354         # Replicate the changes to $TGT
 355         sleep 10 # give dbench a headstart
 356         local quit=0
 357         while [ $quit -le 1 ];
 358         do
 359                 echo "Running lustre_rsync"
 360                 $LRSYNC -s $DIR -t $TGT -t $TGT2 -m ${mds1_svc} -u $CL_USER \
 361                         -l $LREPL_LOG -D $LRSYNC_LOG
 362                 sleep 5
 363                 pgrep dbench
 364                 if [ $? -ne 0 ]; then
 365                         quit=$(expr $quit + 1)
 366                 fi
 367         done
 368
 369         # Use diff to compare the source and the destination
 370         check_diff $DIR/$tdir $TGT/$tdir
 371         check_diff $DIR/$tdir $TGT2/$tdir
 372
 373         fini_changelog
 374         cleanup_src_tgt
 375         return 0
 376 }
 377 run_test 2c "Replicate files while dbench is running."
 378
 379 # Test 3a - Replicate files created by createmany
 380 test_3a() {
 381         init_src
 382         init_changelog
 383
 384         local numfiles=1000
 385         createmany -o $DIR/$tdir/$tfile $numfiles || error "createmany failed"
 386
 387         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 388         # Replicate the changes to $TGT
 389         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 390                 -D $LRSYNC_LOG
 391         check_diff $DIR/$tdir $TGT/$tdir
 392         check_diff $DIR/$tdir $TGT2/$tdir
 393
 394         fini_changelog
 395         cleanup_src_tgt
 396         return 0
 397 }
 398 run_test 3a "Replicate files created by createmany"
 399
 400 # Test 3b - Replicate files created by writemany
 401 test_3b() {
 402         init_src
 403         init_changelog
 404
 405         local time=60
 406         local threads=5
 407         writemany -q -a $DIR/$tdir/$tfile $time $threads ||
 408                 error "writemany failed"
 409
 410         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 411         # Replicate the changes to $TGT
 412         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
 413                 -D $LRSYNC_LOG
 414
 415         check_diff $DIR/$tdir $TGT/$tdir
 416         check_diff $DIR/$tdir $TGT2/$tdir
 417
 418         fini_changelog
 419         cleanup_src_tgt
 420         return 0
 421 }
 422 run_test 3b "Replicate files created by writemany"
 423
 424 # Test 3c - Replicate files created by createmany/unlinkmany
 425 test_3c() {
 426         init_src
 427         init_changelog
 428
 429         local numfiles=1000
 430         createmany -o $DIR/$tdir/$tfile $numfiles || error "createmany failed"
 431         unlinkmany $DIR/$tdir/$tfile $numfiles || error "unlinkmany failed"
 432
 433         local LRSYNC_LOG=$(generate_logname "lrsync_log")
 434         # Replicate the changes to $TGT
 435         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0  -u $CL_USER -l $LREPL_LOG \
 436                 -D $LRSYNC_LOG
 437         check_diff $DIR/$tdir $TGT/$tdir
 438         check_diff $DIR/$tdir $TGT2/$tdir
 439
 440         fini_changelog
 441         cleanup_src_tgt
 442         return 0
 443 }
 444 run_test 3c "Replicate files created by createmany/unlinkmany"
 445
 446 # Test 4 - Replicate files created by iozone
 447 test_4() {
 448         which iozone > /dev/null 2>&1
 449         [ $? -ne 0 ] && skip "iozone not found"
 450
 451         init_src
 452         init_changelog
 453
 454         END_RUN_FILE=${DIR}/$tdir/run LOAD_PID_FILE=${DIR}/$tdir/pid \
 455                 MOUNT=${DIR}/$tdir 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 $SECONDS
 680 check_and_cleanup_lustre
 681 exit_status