8972a98f887c6a34d77e646ce76c9eae3148fce8
[BackupPC.git] / 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.0alpha, released 23 Jan 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.52 ) {
59             $RsyncLibOK = 0;
60             $RsyncLibErr = "File::RsyncP module version"
61                          . " ($File::RsyncP::VERSION) too old: need 0.52";
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             }
222         } else {
223             $incrDate = $bpc->timeStamp($t->{lastFull} - 3600, 1);
224             $logMsg = "incr backup started back to $incrDate for directory"
225                     . " $t->{shareName}";
226         }
227         
228         #
229         # A full dump is implemented with --ignore-times: this causes all
230         # files to be checksummed, even if the attributes are the same.
231         # That way all the file contents are checked, but you get all
232         # the efficiencies of rsync: only files deltas need to be
233         # transferred, even though it is a full dump.
234         #
235         $rsyncArgs = $conf->{RsyncArgs};
236         $rsyncArgs = [@$rsyncArgs, @fileList] if ( @fileList );
237         $rsyncArgs = [@$rsyncArgs, "--ignore-times"]
238                                     if ( $t->{type} eq "full" );
239         $rsyncClientCmd = $conf->{RsyncClientCmd};
240         $argList = ['--server', '--sender', @$rsyncArgs,
241                               '.', $t->{shareNameSlash}];
242         eval {
243             $argList = File::RsyncP->excludeStrip($argList);
244         };
245         $fioArgs = {
246             client     => $t->{client},
247             share      => $t->{shareName},
248             viewNum    => $t->{lastFullBkupNum},
249             partialNum => $t->{partialNum},
250         };
251     }
252
253     #
254     # Merge variables into $rsyncClientCmd
255     #
256     my $args = {
257         host      => $t->{host},
258         hostIP    => $t->{hostIP},
259         client    => $t->{client},
260         shareName => $t->{shareName},
261         shareNameSlash => $t->{shareNameSlash},
262         rsyncPath => $conf->{RsyncClientPath},
263         sshPath   => $conf->{SshPath},
264         argList   => $argList,
265     };
266     $rsyncClientCmd = $bpc->cmdVarSubstitute($rsyncClientCmd, $args);
267
268     #
269     # Create the Rsync object, and tell it to use our own File::RsyncP::FileIO
270     # module, which handles all the special BackupPC file storage
271     # (compression, mangling, hardlinks, special files, attributes etc).
272     #
273     $t->{rsyncClientCmd} = $rsyncClientCmd;
274     $t->{rs} = File::RsyncP->new({
275         logLevel     => $t->{logLevel} || $conf->{RsyncLogLevel},
276         rsyncCmd     => sub {
277                             $bpc->verbose(0);
278                             $bpc->cmdExecOrEval($rsyncClientCmd, $args);
279                         },
280         rsyncCmdType => "full",
281         rsyncArgs    => $rsyncArgs,
282         timeout      => $conf->{ClientTimeout},
283         doPartial    => defined($t->{partialNum}) ? 1 : undef,
284         logHandler   =>
285                 sub {
286                     my($str) = @_;
287                     $str .= "\n";
288                     $t->{XferLOG}->write(\$str);
289                     if ( $str =~ /^Remote\[1\]: read errors mapping "(.*)"/ ) {
290                         #
291                         # Files with read errors (eg: region locked files
292                         # on WinXX) are filled with 0 by rsync.  Remember
293                         # them and delete them later.
294                         #
295                         my $badFile = $1;
296                         $badFile =~ s/^\/+//;
297                         push(@{$t->{badFiles}}, {
298                                 share => $t->{shareName},
299                                 file  => $badFile
300                             });
301                     }
302                 },
303         pidHandler   => sub {
304                             $t->{pidHandler}(@_);
305                         },
306         clientCharset => $conf->{ClientCharset},
307         fio          => BackupPC::Xfer::RsyncFileIO->new({
308                             xfer       => $t,
309                             bpc        => $t->{bpc},
310                             conf       => $t->{conf},
311                             backups    => $t->{backups},
312                             logLevel   => $t->{logLevel}
313                                               || $conf->{RsyncLogLevel},
314                             logHandler => sub {
315                                               my($str) = @_;
316                                               $str .= "\n";
317                                               $t->{XferLOG}->write(\$str);
318                                           },
319                             cacheCheckProb => $conf->{RsyncCsumCacheVerifyProb},
320                             clientCharset  => $conf->{ClientCharset},
321                             %$fioArgs,
322                       }),
323     });
324
325     delete($t->{_errStr});
326
327     return $logMsg;
328 }
329
330 sub run
331 {
332     my($t) = @_;
333     my $rs = $t->{rs};
334     my $conf = $t->{conf};
335     my($remoteSend, $remoteDir, $remoteDirDaemon);
336
337     alarm($conf->{ClientTimeout});
338     if ( $t->{type} eq "restore" ) {
339         $remoteSend       = 0;
340         ($remoteDir       = "$t->{shareName}/$t->{pathHdrDest}") =~ s{//+}{/}g;
341         ($remoteDirDaemon = "$t->{shareName}/$t->{pathHdrDest}") =~ s{//+}{/}g;
342         $remoteDirDaemon  = $t->{shareNameSlash}
343                                 if ( $t->{pathHdrDest} eq ""
344                                               || $t->{pathHdrDest} eq "/" );
345     } else {
346         $remoteSend      = 1;
347         $remoteDir       = $t->{shareNameSlash};
348         $remoteDirDaemon = ".";
349     }
350     if ( $t->{XferMethod} eq "rsync" ) {
351         #
352         # Run rsync command
353         #
354         my $str = "Running: "
355                 . $t->{bpc}->execCmd2ShellCmd(@{$t->{rsyncClientCmd}})
356                 . "\n";
357         $t->{XferLOG}->write(\$str);
358         $rs->remoteStart($remoteSend, $remoteDir);
359     } else {
360         #
361         # Connect to the rsync server
362         #
363         if ( defined(my $err = $rs->serverConnect($t->{hostIP},
364                                              $conf->{RsyncdClientPort})) ) {
365             $t->{hostError} = $err;
366             my $str = "Error connecting to rsync daemon at $t->{hostIP}"
367                     . ":$conf->{RsyncdClientPort}: $err\n";
368             $t->{XferLOG}->write(\$str);
369             return;
370         }
371         #
372         # Pass module name, and follow it with a slash if it already
373         # contains a slash; otherwise just keep the plain module name.
374         #
375         my $module = $t->{shareName};
376         $module = $t->{shareNameSlash} if ( $module =~ /\// );
377         if ( defined(my $err = $rs->serverService($module,
378                                              $conf->{RsyncdUserName},
379                                              $conf->{RsyncdPasswd},
380                                              $conf->{RsyncdAuthRequired})) ) {
381             my $str = "Error connecting to module $module at $t->{hostIP}"
382                     . ":$conf->{RsyncdClientPort}: $err\n";
383             $t->{XferLOG}->write(\$str);
384             $t->{hostError} = $err;
385             return;
386         }
387         $rs->serverStart($remoteSend, $remoteDirDaemon);
388     }
389     my $error = $rs->go($t->{shareNameSlash});
390     $rs->serverClose();
391
392     #
393     # TODO: generate sensible stats
394     # 
395     # $rs->{stats}{totalWritten}
396     # $rs->{stats}{totalSize}
397     #
398     my $stats = $rs->statsFinal;
399     if ( !defined($error) && defined($stats) ) {
400         $t->{xferOK} = 1;
401     } else {
402         $t->{xferOK} = 0;
403     }
404     $t->{xferErrCnt} = $stats->{remoteErrCnt}
405                      + $stats->{childStats}{errorCnt}
406                      + $stats->{parentStats}{errorCnt};
407     $t->{byteCnt}    = $stats->{childStats}{TotalFileSize}
408                      + $stats->{parentStats}{TotalFileSize};
409     $t->{fileCnt}    = $stats->{childStats}{TotalFileCnt}
410                      + $stats->{parentStats}{TotalFileCnt};
411     my $str = "Done: $t->{fileCnt} files, $t->{byteCnt} bytes\n";
412     $t->{XferLOG}->write(\$str);
413     #
414     # TODO: get error count, and call fio to get stats...
415     #
416     $t->{hostError} = $error if ( defined($error) );
417
418     if ( $t->{type} eq "restore" ) {
419         return (
420             $t->{fileCnt},
421             $t->{byteCnt},
422             0,
423             0
424         );
425     } else {
426         return (
427             0,
428             $stats->{childStats}{ExistFileCnt}
429                 + $stats->{parentStats}{ExistFileCnt},
430             $stats->{childStats}{ExistFileSize}
431                 + $stats->{parentStats}{ExistFileSize},
432             $stats->{childStats}{ExistFileCompSize}
433                 + $stats->{parentStats}{ExistFileCompSize},
434             $stats->{childStats}{TotalFileCnt}
435                 + $stats->{parentStats}{TotalFileCnt},
436             $stats->{childStats}{TotalFileSize}
437                 + $stats->{parentStats}{TotalFileSize},
438         );
439     }
440 }
441
442 sub abort
443 {
444     my($t, $reason) = @_;
445     my $rs = $t->{rs};
446
447     $rs->abort($reason);
448     return 1;
449 }
450
451 sub setSelectMask
452 {
453     my($t, $FDreadRef) = @_;
454 }
455
456 sub errStr
457 {
458     my($t) = @_;
459
460     return $RsyncLibErr if ( !defined($t) || ref($t) ne "HASH" );
461     return $t->{_errStr};
462 }
463
464 sub xferPid
465 {
466     my($t) = @_;
467
468     return ();
469 }
470
471 sub logMsg
472 {
473     my($t, $msg) = @_;
474
475     push(@{$t->{_logMsg}}, $msg);
476 }
477
478 sub logMsgGet
479 {
480     my($t) = @_;
481
482     return shift(@{$t->{_logMsg}});
483 }
484
485 #
486 # Returns a hash ref giving various status information about
487 # the transfer.
488 #
489 sub getStats
490 {
491     my($t) = @_;
492
493     return { map { $_ => $t->{$_} }
494             qw(byteCnt fileCnt xferErrCnt xferBadShareCnt xferBadFileCnt
495                xferOK hostAbort hostError lastOutputLine)
496     };
497 }
498
499 sub getBadFiles
500 {
501     my($t) = @_;
502
503     return @{$t->{badFiles}};
504 }
505
506 1;