lib/BackupPC/Xfer/Rsync.pm

   1 #============================================================= -*-perl-*-
   2 #
   3 # BackupPC::Xfer::Rsync package
   4 #
   5 # DESCRIPTION
   6 #
   7 #   This library defines a BackupPC::Xfer::Rsync class for managing
   8 #   the rsync-based transport of backup data from the client.
   9 #
  10 # AUTHOR
  11 #   Craig Barratt  <cbarratt@users.sourceforge.net>
  12 #
  13 # COPYRIGHT
  14 #   Copyright (C) 2002-2003  Craig Barratt
  15 #
  16 #   This program is free software; you can redistribute it and/or modify
  17 #   it under the terms of the GNU General Public License as published by
  18 #   the Free Software Foundation; either version 2 of the License, or
  19 #   (at your option) any later version.
  20 #
  21 #   This program is distributed in the hope that it will be useful,
  22 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 #   GNU General Public License for more details.
  25 #
  26 #   You should have received a copy of the GNU General Public License
  27 #   along with this program; if not, write to the Free Software
  28 #   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  29 #
  30 #========================================================================
  31 #
  32 # Version 3.0.0beta0, released 11 Jul 2006.
  33 #
  34 # See http://backuppc.sourceforge.net.
  35 #
  36 #========================================================================
  37
  38 package BackupPC::Xfer::Rsync;
  39
  40 use strict;
  41 use BackupPC::View;
  42 use BackupPC::Xfer::RsyncFileIO;
  43
  44 use vars qw( $RsyncLibOK $RsyncLibErr );
  45
  46 BEGIN {
  47     eval "use File::RsyncP;";
  48     if ( $@ ) {
  49         #
  50         # Rsync module doesn't exist.
  51         #
  52         $RsyncLibOK = 0;
  53         $RsyncLibErr = "File::RsyncP module doesn't exist";
  54     } else {
  55         #
  56         # Note: also update configure.pl when this version number is changed!
  57         #
  58         if ( $File::RsyncP::VERSION < 0.62 ) {
  59             $RsyncLibOK = 0;
  60             $RsyncLibErr = "File::RsyncP module version"
  61                          . " ($File::RsyncP::VERSION) too old: need 0.62";
  62         } else {
  63             $RsyncLibOK = 1;
  64         }
  65     }
  66 };
  67
  68 sub new
  69 {
  70     my($class, $bpc, $args) = @_;
  71
  72     return if ( !$RsyncLibOK );
  73     $args ||= {};
  74     my $t = bless {
  75         bpc       => $bpc,
  76         conf      => { $bpc->Conf },
  77         host      => "",
  78         hostIP    => "",
  79         shareName => "",
  80         badFiles  => [],
  81
  82         #
  83         # Various stats
  84         #
  85         byteCnt         => 0,
  86         fileCnt         => 0,
  87         xferErrCnt      => 0,
  88         xferBadShareCnt => 0,
  89         xferBadFileCnt  => 0,
  90         xferOK          => 0,
  91
  92         #
  93         # User's args
  94         #
  95         %$args,
  96     }, $class;
  97
  98     return $t;
  99 }
 100
 101 sub args
 102 {
 103     my($t, $args) = @_;
 104
 105     foreach my $arg ( keys(%$args) ) {
 106         $t->{$arg} = $args->{$arg};
 107     }
 108 }
 109
 110 sub useTar
 111 {
 112     return 0;
 113 }
 114
 115 sub start
 116 {
 117     my($t) = @_;
 118     my $bpc = $t->{bpc};
 119     my $conf = $t->{conf};
 120     my(@fileList, $rsyncClientCmd, $rsyncArgs, $logMsg,
 121        $incrDate, $argList, $fioArgs);
 122
 123     #
 124     # We add a slash to the share name we pass to rsync
 125     #
 126     ($t->{shareNameSlash} = "$t->{shareName}/") =~ s{//+$}{/};
 127
 128     if ( $t->{type} eq "restore" ) {
 129         $rsyncClientCmd = $conf->{RsyncClientRestoreCmd};
 130         $rsyncArgs = $conf->{RsyncRestoreArgs};
 131         my $remoteDir = "$t->{shareName}/$t->{pathHdrDest}";
 132         $remoteDir    =~ s{//+}{/}g;
 133         $argList = ['--server', @$rsyncArgs, '.', $remoteDir];
 134         $fioArgs = {
 135             client   => $t->{bkupSrcHost},
 136             share    => $t->{bkupSrcShare},
 137             viewNum  => $t->{bkupSrcNum},
 138             fileList => $t->{fileList},
 139         };
 140         $logMsg = "restore started below directory $t->{shareName}"
 141                 . " to host $t->{host}";
 142     } else {
 143         #
 144         # Turn $conf->{BackupFilesOnly} and $conf->{BackupFilesExclude}
 145         # into a hash of arrays of files, and $conf->{RsyncShareName}
 146         # to an array
 147         #
 148         $bpc->backupFileConfFix($conf, "RsyncShareName");
 149
 150         if ( defined($conf->{BackupFilesOnly}{$t->{shareName}}) ) {
 151             my(@inc, @exc, %incDone, %excDone);
 152             foreach my $file ( @{$conf->{BackupFilesOnly}{$t->{shareName}}} ) {
 153                 #
 154                 # If the user wants to just include /home/craig, then
 155                 # we need to do create include/exclude pairs at
 156                 # each level:
 157                 #     --include /home --exclude /*
 158                 #     --include /home/craig --exclude /home/*
 159                 #
 160                 # It's more complex if the user wants to include multiple
 161                 # deep paths.  For example, if they want /home/craig and
 162                 # /var/log, then we need this mouthfull:
 163                 #     --include /home --include /var --exclude /*
 164                 #     --include /home/craig --exclude /home/*
 165                 #     --include /var/log --exclude /var/*
 166                 #
 167                 # To make this easier we do all the includes first and all
 168                 # of the excludes at the end (hopefully they commute).
 169                 #
 170                 $file =~ s{/$}{};
 171                 $file = "/$file";
 172                 $file =~ s{//+}{/}g;
 173                 if ( $file eq "/" ) {
 174                     #
 175                     # This is a special case: if the user specifies
 176                     # "/" then just include it and don't exclude "/*".
 177                     #
 178                     push(@inc, $file) if ( !$incDone{$file} );
 179                     next;
 180                 }
 181                 my $f = "";
 182                 while ( $file =~ m{^/([^/]*)(.*)} ) {
 183                     my $elt = $1;
 184                     $file = $2;
 185                     if ( $file eq "/" ) {
 186                         #
 187                         # preserve a tailing slash
 188                         #
 189                         $file = "";
 190                         $elt = "$elt/";
 191                     }
 192                     push(@exc, "$f/*") if ( !$excDone{"$f/*"} );
 193                     $excDone{"$f/*"} = 1;
 194                     $f = "$f/$elt";
 195                     push(@inc, $f) if ( !$incDone{$f} );
 196                     $incDone{$f} = 1;
 197                 }
 198             }
 199             foreach my $file ( @inc ) {
 200                 push(@fileList, "--include=$file");
 201             }
 202             foreach my $file ( @exc ) {
 203                 push(@fileList, "--exclude=$file");
 204             }
 205         }
 206         if ( defined($conf->{BackupFilesExclude}{$t->{shareName}}) ) {
 207             foreach my $file ( @{$conf->{BackupFilesExclude}{$t->{shareName}}} )
 208             {
 209                 #
 210                 # just append additional exclude lists onto the end
 211                 #
 212                 push(@fileList, "--exclude=$file");
 213             }
 214         }
 215         if ( $t->{type} eq "full" ) {
 216             if ( $t->{partialNum} ) {
 217                 $logMsg = "full backup started for directory $t->{shareName};"
 218                         . " updating partial #$t->{partialNum}";
 219             } else {
 220                 $logMsg = "full backup started for directory $t->{shareName}";
 221                 if ( $t->{incrBaseBkupNum} ne "" ) {
 222                     $logMsg .= " (baseline backup #$t->{incrBaseBkupNum})";
 223                 }
 224             }
 225         } else {
 226             $incrDate = $bpc->timeStamp($t->{incrBaseTime}, 1);
 227             $logMsg = "incr backup started back to $incrDate"
 228                     . " (backup #$t->{incrBaseBkupNum}) for directory"
 229                     . " $t->{shareName}";
 230         }
 231
 232         #
 233         # A full dump is implemented with --ignore-times: this causes all
 234         # files to be checksummed, even if the attributes are the same.
 235         # That way all the file contents are checked, but you get all
 236         # the efficiencies of rsync: only files deltas need to be
 237         # transferred, even though it is a full dump.
 238         #
 239         $rsyncArgs = $conf->{RsyncArgs};
 240         $rsyncArgs = [@$rsyncArgs, @fileList] if ( @fileList );
 241         $rsyncArgs = [@$rsyncArgs, "--ignore-times"]
 242                                     if ( $t->{type} eq "full" );
 243         $rsyncClientCmd = $conf->{RsyncClientCmd};
 244         $argList = ['--server', '--sender', @$rsyncArgs,
 245                               '.', $t->{shareNameSlash}];
 246         eval {
 247             $argList = File::RsyncP->excludeStrip($argList);
 248         };
 249         $fioArgs = {
 250             client     => $t->{client},
 251             share      => $t->{shareName},
 252             viewNum    => $t->{incrBaseBkupNum},
 253             partialNum => $t->{partialNum},
 254         };
 255     }
 256
 257     #
 258     # Merge variables into $rsyncClientCmd
 259     #
 260     my $args = {
 261         host      => $t->{host},
 262         hostIP    => $t->{hostIP},
 263         client    => $t->{client},
 264         shareName => $t->{shareName},
 265         shareNameSlash => $t->{shareNameSlash},
 266         rsyncPath => $conf->{RsyncClientPath},
 267         sshPath   => $conf->{SshPath},
 268         argList   => $argList,
 269     };
 270     $rsyncClientCmd = $bpc->cmdVarSubstitute($rsyncClientCmd, $args);
 271
 272     #
 273     # Create the Rsync object, and tell it to use our own File::RsyncP::FileIO
 274     # module, which handles all the special BackupPC file storage
 275     # (compression, mangling, hardlinks, special files, attributes etc).
 276     #
 277     $t->{rsyncClientCmd} = $rsyncClientCmd;
 278     $t->{rs} = File::RsyncP->new({
 279         logLevel     => $t->{logLevel} || $conf->{RsyncLogLevel},
 280         rsyncCmd     => sub {
 281                             $bpc->verbose(0);
 282                             $bpc->cmdExecOrEval($rsyncClientCmd, $args);
 283                         },
 284         rsyncCmdType => "full",
 285         rsyncArgs    => $rsyncArgs,
 286         timeout      => $conf->{ClientTimeout},
 287         doPartial    => defined($t->{partialNum}) ? 1 : undef,
 288         logHandler   =>
 289                 sub {
 290                     my($str) = @_;
 291                     $str .= "\n";
 292                     $t->{XferLOG}->write(\$str);
 293                     if ( $str =~ /^Remote\[1\]: read errors mapping "(.*)"/ ) {
 294                         #
 295                         # Files with read errors (eg: region locked files
 296                         # on WinXX) are filled with 0 by rsync.  Remember
 297                         # them and delete them later.
 298                         #
 299                         my $badFile = $1;
 300                         $badFile =~ s/^\/+//;
 301                         push(@{$t->{badFiles}}, {
 302                                 share => $t->{shareName},
 303                                 file  => $badFile
 304                             });
 305                     }
 306                 },
 307         pidHandler   => sub {
 308                             $t->{pidHandler}(@_);
 309                         },
 310         clientCharset => $conf->{ClientCharset},
 311         fio          => BackupPC::Xfer::RsyncFileIO->new({
 312                             xfer       => $t,
 313                             bpc        => $t->{bpc},
 314                             conf       => $t->{conf},
 315                             backups    => $t->{backups},
 316                             logLevel   => $t->{logLevel}
 317                                               || $conf->{RsyncLogLevel},
 318                             logHandler => sub {
 319                                               my($str) = @_;
 320                                               $str .= "\n";
 321                                               $t->{XferLOG}->write(\$str);
 322                                           },
 323                             cacheCheckProb => $conf->{RsyncCsumCacheVerifyProb},
 324                             clientCharset  => $conf->{ClientCharset},
 325                             %$fioArgs,
 326                       }),
 327     });
 328
 329     delete($t->{_errStr});
 330
 331     return $logMsg;
 332 }
 333
 334 sub run
 335 {
 336     my($t) = @_;
 337     my $rs = $t->{rs};
 338     my $conf = $t->{conf};
 339     my($remoteSend, $remoteDir, $remoteDirDaemon);
 340
 341     alarm($conf->{ClientTimeout});
 342     if ( $t->{type} eq "restore" ) {
 343         $remoteSend       = 0;
 344         ($remoteDir       = "$t->{shareName}/$t->{pathHdrDest}") =~ s{//+}{/}g;
 345         ($remoteDirDaemon = "$t->{shareName}/$t->{pathHdrDest}") =~ s{//+}{/}g;
 346         $remoteDirDaemon  = $t->{shareNameSlash}
 347                                 if ( $t->{pathHdrDest} eq ""
 348                                               || $t->{pathHdrDest} eq "/" );
 349     } else {
 350         $remoteSend      = 1;
 351         $remoteDir       = $t->{shareNameSlash};
 352         $remoteDirDaemon = ".";
 353     }
 354     if ( $t->{XferMethod} eq "rsync" ) {
 355         #
 356         # Run rsync command
 357         #
 358         my $str = "Running: "
 359                 . $t->{bpc}->execCmd2ShellCmd(@{$t->{rsyncClientCmd}})
 360                 . "\n";
 361         $t->{XferLOG}->write(\$str);
 362         $rs->remoteStart($remoteSend, $remoteDir);
 363     } else {
 364         #
 365         # Connect to the rsync server
 366         #
 367         if ( defined(my $err = $rs->serverConnect($t->{hostIP},
 368                                              $conf->{RsyncdClientPort})) ) {
 369             $t->{hostError} = $err;
 370             my $str = "Error connecting to rsync daemon at $t->{hostIP}"
 371                     . ":$conf->{RsyncdClientPort}: $err\n";
 372             $t->{XferLOG}->write(\$str);
 373             return;
 374         }
 375         #
 376         # Pass module name, and follow it with a slash if it already
 377         # contains a slash; otherwise just keep the plain module name.
 378         #
 379         my $module = $t->{shareName};
 380         $module = $t->{shareNameSlash} if ( $module =~ /\// );
 381         if ( defined(my $err = $rs->serverService($module,
 382                                              $conf->{RsyncdUserName},
 383                                              $conf->{RsyncdPasswd},
 384                                              $conf->{RsyncdAuthRequired})) ) {
 385             my $str = "Error connecting to module $module at $t->{hostIP}"
 386                     . ":$conf->{RsyncdClientPort}: $err\n";
 387             $t->{XferLOG}->write(\$str);
 388             $t->{hostError} = $err;
 389             return;
 390         }
 391         $rs->serverStart($remoteSend, $remoteDirDaemon);
 392     }
 393     my $error = $rs->go($t->{shareNameSlash});
 394     $rs->serverClose();
 395
 396     #
 397     # TODO: generate sensible stats
 398     #
 399     # $rs->{stats}{totalWritten}
 400     # $rs->{stats}{totalSize}
 401     #
 402     my $stats = $rs->statsFinal;
 403     if ( !defined($error) && defined($stats) ) {
 404         $t->{xferOK} = 1;
 405     } else {
 406         $t->{xferOK} = 0;
 407     }
 408     $t->{xferErrCnt} = $stats->{remoteErrCnt}
 409                      + $stats->{childStats}{errorCnt}
 410                      + $stats->{parentStats}{errorCnt};
 411     $t->{byteCnt}    = $stats->{childStats}{TotalFileSize}
 412                      + $stats->{parentStats}{TotalFileSize};
 413     $t->{fileCnt}    = $stats->{childStats}{TotalFileCnt}
 414                      + $stats->{parentStats}{TotalFileCnt};
 415     my $str = "Done: $t->{fileCnt} files, $t->{byteCnt} bytes\n";
 416     $t->{XferLOG}->write(\$str);
 417     #
 418     # TODO: get error count, and call fio to get stats...
 419     #
 420     $t->{hostError} = $error if ( defined($error) );
 421
 422     if ( $t->{type} eq "restore" ) {
 423         return (
 424             $t->{fileCnt},
 425             $t->{byteCnt},
 426             0,
 427             0
 428         );
 429     } else {
 430         return (
 431             0,
 432             $stats->{childStats}{ExistFileCnt}
 433                 + $stats->{parentStats}{ExistFileCnt},
 434             $stats->{childStats}{ExistFileSize}
 435                 + $stats->{parentStats}{ExistFileSize},
 436             $stats->{childStats}{ExistFileCompSize}
 437                 + $stats->{parentStats}{ExistFileCompSize},
 438             $stats->{childStats}{TotalFileCnt}
 439                 + $stats->{parentStats}{TotalFileCnt},
 440             $stats->{childStats}{TotalFileSize}
 441                 + $stats->{parentStats}{TotalFileSize},
 442         );
 443     }
 444 }
 445
 446 sub abort
 447 {
 448     my($t, $reason) = @_;
 449     my $rs = $t->{rs};
 450
 451     $rs->abort($reason);
 452     return 1;
 453 }
 454
 455 sub setSelectMask
 456 {
 457     my($t, $FDreadRef) = @_;
 458 }
 459
 460 sub errStr
 461 {
 462     my($t) = @_;
 463
 464     return $RsyncLibErr if ( !defined($t) || ref($t) ne "HASH" );
 465     return $t->{_errStr};
 466 }
 467
 468 sub xferPid
 469 {
 470     my($t) = @_;
 471
 472     return ();
 473 }
 474
 475 sub logMsg
 476 {
 477     my($t, $msg) = @_;
 478
 479     push(@{$t->{_logMsg}}, $msg);
 480 }
 481
 482 sub logMsgGet
 483 {
 484     my($t) = @_;
 485
 486     return shift(@{$t->{_logMsg}});
 487 }
 488
 489 #
 490 # Returns a hash ref giving various status information about
 491 # the transfer.
 492 #
 493 sub getStats
 494 {
 495     my($t) = @_;
 496
 497     return { map { $_ => $t->{$_} }
 498             qw(byteCnt fileCnt xferErrCnt xferBadShareCnt xferBadFileCnt
 499                xferOK hostAbort hostError lastOutputLine)
 500     };
 501 }
 502
 503 sub getBadFiles
 504 {
 505     my($t) = @_;
 506
 507     return @{$t->{badFiles}};
 508 }
 509
 510 1;