/[BackupPC]/trunk/bin/BackupPC_updatedb
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/bin/BackupPC_updatedb

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 44 by dpavlin, Sat Aug 20 11:24:55 2005 UTC revision 95 by dpavlin, Tue Aug 30 09:55:34 2005 UTC
# Line 1  Line 1 
1  #!/usr/local/bin/perl -w  #!/usr/local/bin/perl -w
2    
3  use strict;  use strict;
 use DBI;  
4  use lib "__INSTALLDIR__/lib";  use lib "__INSTALLDIR__/lib";
5    
6    use DBI;
7  use BackupPC::Lib;  use BackupPC::Lib;
8  use BackupPC::View;  use BackupPC::View;
9  use Data::Dumper;  use Data::Dumper;
# Line 10  use Getopt::Std; Line 11  use Getopt::Std;
11  use Time::HiRes qw/time/;  use Time::HiRes qw/time/;
12  use File::Pid;  use File::Pid;
13  use POSIX qw/strftime/;  use POSIX qw/strftime/;
14    
15  use constant BPC_FTYPE_DIR => 5;  use constant BPC_FTYPE_DIR => 5;
16    
17  my $debug = 0;  my $debug = 0;
18  $|=1;  $|=1;
19    
20    my $start_t = time();
21    
22  my $pidfile = new File::Pid;  my $pidfile = new File::Pid;
23    
24  if (my $pid = $pidfile->running ) {  if (my $pid = $pidfile->running ) {
# Line 34  my %Conf = $bpc->Conf(); Line 38  my %Conf = $bpc->Conf();
38  my $TopDir = $bpc->TopDir();  my $TopDir = $bpc->TopDir();
39  my $beenThere = {};  my $beenThere = {};
40    
41  my $dsn = "dbi:SQLite:dbname=$TopDir/$Conf{SearchDB}";  my $dsn = $Conf{SearchDSN} || die "Need SearchDSN in config.pl\n";
42    my $user = $Conf{SearchUser} || '';
43    my $index_path = $Conf{HyperEstraierIndex};
44    $index_path = $TopDir . '/' . $index_path;
45    $index_path =~ s#//#/#g;
46    
47    
48  my $dbh = DBI->connect($dsn, "", "", { RaiseError => 1, AutoCommit => 0 });  my $dbh = DBI->connect($dsn, $user, "", { RaiseError => 1, AutoCommit => 0 });
49    
50  my %opt;  my %opt;
51    
52  if ( !getopts("cdm:v:", \%opt ) ) {  if ( !getopts("cdm:v:i", \%opt ) ) {
53          print STDERR <<EOF;          print STDERR <<EOF;
54  usage: $0 [-c|-d] [-m num] [-v|-v level]  usage: $0 [-c|-d] [-m num] [-v|-v level] [-i]
55    
56  Options:  Options:
57          -c      create database on first use          -c      create database on first use
58          -d      delete database before import          -d      delete database before import
59          -m num  import just num increments for one host          -m num  import just num increments for one host
60          -v num  set verbosity (debug) level (default $debug)          -v num  set verbosity (debug) level (default $debug)
61            -i      update HyperEstraier full text index
62  EOF  EOF
63          exit 1;          exit 1;
64  }  }
65    
66  ###################################create tables############################3  if ($opt{v}) {
67            print "Debug level at $opt{v}\n";
68            $debug = $opt{v};
69    }
70    
71    #---- subs ----
72    
73    sub fmt_time {
74            my $t = shift || return;
75            my $out = "";
76            my ($ss,$mm,$hh) = gmtime($t);
77            $out .= "${hh}h" if ($hh);
78            $out .= sprintf("%02d:%02d", $mm,$ss);
79            return $out;
80    }
81    
82    sub curr_time {
83            return strftime($t_fmt,localtime());
84    }
85    
86    my $hest_db;
87    
88    sub hest_update {
89    
90            my ($host_id, $share_id, $num) = @_;
91    
92            print curr_time," updating HyperEstraier: select files";
93    
94            my $t = time();
95    
96            my $where = '';
97            if ($host_id && $share_id && $num) {
98                    $where = qq{
99                    WHERE
100                            hosts.id = ? AND
101                            shares.id = ? AND
102                            files.backupnum = ?
103                    };
104            }
105    
106            my $sth = $dbh->prepare(qq{
107                    SELECT
108                            files.id                        AS fid,
109                            hosts.name                      AS hname,
110                            shares.name                     AS sname,
111                            -- shares.share                 AS sharename,
112                            files.backupnum                 AS backupnum,
113                            -- files.name                   AS filename,
114                            files.path                      AS filepath,
115                            files.date                      AS date,
116                            files.type                      AS type,
117                            files.size                      AS size,
118                            files.shareid                   AS shareid,
119                            backups.date                    AS backup_date
120                    FROM files
121                            INNER JOIN shares       ON files.shareID=shares.ID
122                            INNER JOIN hosts        ON hosts.ID = shares.hostID
123                            INNER JOIN backups      ON backups.num = files.backupNum and backups.hostID = hosts.ID AND backups.shareID = shares.ID
124                    $where
125            });
126    
127            $sth->execute(@_);
128            my $results = $sth->rows;
129    
130            if ($results == 0) {
131                    print " - no files, skipping\n";
132                    return;
133            }
134    
135            my $dot = int($results / 15) || 1;
136    
137            print " $results ($dot/#)";
138    
139            sub fmt_date {
140                    my $t = shift || return;
141                    my $iso = BackupPC::Lib::timeStamp($t);
142                    $iso =~ s/\s/T/;
143                    return $iso;
144            }
145    
146            my $max = int($results / $dot);
147    
148            print ", opening index $index_path...";
149            use HyperEstraier;
150            my $db = HyperEstraier::Database->new();
151    
152    #       unless ($hest_db) {
153    #               print " open reader";
154    #               $hest_db = HyperEstraier::Database->new();
155    #
156    #       }
157    
158    
159            $db->open($index_path, $HyperEstraier::Database::DBWRITER | $HyperEstraier::Database::DBCREAT);
160    
161            my $added = 0;
162    
163            while (my $row = $sth->fetchrow_hashref()) {
164    
165                    my $fid = $row->{'fid'} || die "no fid?";
166                    my $uri = 'file:///' . $fid;
167    
168                    my $id = $db->uri_to_id($uri);
169                    next unless ($id == -1);
170    
171                    # create a document object
172                    my $doc = HyperEstraier::Document->new;
173    
174                    # add attributes to the document object
175                    $doc->add_attr('@uri', $uri);
176    
177                    foreach my $c (@{ $sth->{NAME} }) {
178                            $doc->add_attr($c, $row->{$c}) if ($row->{$c});
179                    }
180    
181                    #$doc->add_attr('@cdate', fmt_date($row->{'date'}));
182    
183                    # add the body text to the document object
184                    my $path = $row->{'filepath'};
185                    $doc->add_text($path);
186                    $path =~ s/(.)/$1 /g;
187                    $doc->add_hidden_text($path);
188    
189                    print STDERR $doc->dump_draft,"\n" if ($debug > 1);
190    
191                    # register the document object to the database
192                    $db->put_doc($doc, $HyperEstraier::Database::PDCLEAN);
193    
194                    $added++;
195                    if ($added % $dot == 0) {
196                            print "$max ";
197                            $max--;
198                    }
199    
200            }
201    
202            print "sync $added new files";
203            $db->sync();
204            print ", close";
205            $db->close();
206    
207            my $dur = (time() - $t) || 1;
208            printf(" [%.2f/s new %.2f/s dur: %s]\n",
209                    ( $results / $dur ),
210                    ( $added / $dur ),
211                    fmt_time($dur)
212            );
213    }
214    
215    #---- /subs ----
216    
217    
218    ## update index ##
219    if (($opt{i} || ($index_path && ! -e $index_path)) && !$opt{c}) {
220            # update all
221            print "force update of HyperEstraier index ";
222            print "importing existing data" unless (-e $index_path);
223            print "by -i flag" if ($opt{i});
224            print "\n";
225            hest_update();
226    }
227    
228    ## create tables ##
229  if ($opt{c}) {  if ($opt{c}) {
230            sub do_index {
231                    my $index = shift || return;
232                    my ($table,$col,$unique) = split(/_/, $index);
233                    $unique ||= '';
234                    $index =~ s/,/_/g;
235                    $dbh->do(qq{ create $unique index $index on $table($col) });
236            }
237    
238          print "creating tables...\n";          print "creating tables...\n";
239                
240          $dbh->do(qq{          $dbh->do(qq{
241                  create table hosts (                  create table hosts (
242                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
243                          name    VARCHAR(30)     NOT NULL,                          name    VARCHAR(30)     NOT NULL,
244                          IP      VARCHAR(15)                          IP      VARCHAR(15)
245                  );                              );            
# Line 68  if ($opt{c}) { Line 247  if ($opt{c}) {
247                                
248          $dbh->do(qq{          $dbh->do(qq{
249                  create table shares (                  create table shares (
250                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
251                          hostID  INTEGER         NOT NULL references hosts(id),                          hostID  INTEGER         NOT NULL references hosts(id),
252                          name    VARCHAR(30)     NOT NULL,                          name    VARCHAR(30)     NOT NULL,
253                          share   VARCHAR(200)    NOT NULL,                          share   VARCHAR(200)    NOT NULL,
# Line 80  if ($opt{c}) { Line 259  if ($opt{c}) {
259                  create table backups (                  create table backups (
260                          hostID  INTEGER         NOT NULL references hosts(id),                          hostID  INTEGER         NOT NULL references hosts(id),
261                          num     INTEGER         NOT NULL,                          num     INTEGER         NOT NULL,
262                          date    DATE,                          date    integer         NOT NULL,
263                          type    CHAR(1),                          type    CHAR(4)         not null,
264                          PRIMARY KEY(hostID, num)                          shareID integer         not null references shares(id),
265                            size    integer         not null,
266                            PRIMARY KEY(hostID, num, shareID)
267                  );                              );            
268          });          });
269    
270            #do_index('backups_hostid,num_unique');
271    
272          $dbh->do(qq{          $dbh->do(qq{
273                  create table dvds (                  create table dvds (
274                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
275                          num     INTEGER         NOT NULL,                          num     INTEGER         NOT NULL,
276                          name    VARCHAR(255)    NOT NULL,                          name    VARCHAR(255)    NOT NULL,
277                          mjesto  VARCHAR(255)                          mjesto  VARCHAR(255)
# Line 97  if ($opt{c}) { Line 280  if ($opt{c}) {
280    
281          $dbh->do(qq{              $dbh->do(qq{    
282                  create table files (                  create table files (
283                          ID      INTEGER         NOT NULL PRIMARY KEY,                            ID      SERIAL          PRIMARY KEY,  
284                          shareID INTEGER         NOT NULL references shares(id),                          shareID INTEGER         NOT NULL references shares(id),
285                          backupNum  INTEGER      NOT NULL references backups(num),                          backupNum  INTEGER      NOT NULL,
286                          name       VARCHAR(255) NOT NULL,                          name       VARCHAR(255) NOT NULL,
287                          path       VARCHAR(255) NOT NULL,                          path       VARCHAR(255) NOT NULL,
288                          fullpath   VARCHAR(255) NOT NULL,                          date       integer      NOT NULL,
                         date       TIMESTAMP    NOT NULL,  
289                          type       INTEGER      NOT NULL,                          type       INTEGER      NOT NULL,
290                          size       INTEGER      NOT NULL,                          size       INTEGER      NOT NULL,
291                          dvdid      INTEGER      references dvds(id)                              dvdid      INTEGER      references dvds(id)    
292                  );                  );
293          });          });
294    
295          print "creating indexes...\n";          print "creating indexes:";
296    
297          foreach my $index (qw(          foreach my $index (qw(
298                  hosts_name                  hosts_name
# Line 124  if ($opt{c}) { Line 306  if ($opt{c}) {
306                  files_date                  files_date
307                  files_size                  files_size
308          )) {          )) {
309                  my ($table,$col) = split(/_/, $index);                  print " $index";
310                  $dbh->do(qq{ create index $index on $table($col) });                  do_index($index);
311          }          }
312            print "...\n";
313    
314            $dbh->commit;
315    
316  }  }
317    
318    ## delete data before inseting ##
319  if ($opt{d}) {  if ($opt{d}) {
320          print "deleting ";          print "deleting ";
321          foreach my $table (qw(hosts shares files dvds backups)) {          foreach my $table (qw(files dvds backups shares hosts)) {
322                  print "$table ";                  print "$table ";
323                  $dbh->do(qq{ DELETE FROM $table });                  $dbh->do(qq{ DELETE FROM $table });
324          }          }
325          print " done...\n";          print " done...\n";
 }  
326    
327  if ($opt{v}) {          $dbh->commit;
         print "Debug level at $opt{v}\n";  
         $debug = $opt{v};  
328  }  }
329    
330  #################################INSERT VALUES#############################  ## insert new values ##
331    
332  # get hosts  # get hosts
333  $hosts = $bpc->HostInfoRead();  $hosts = $bpc->HostInfoRead();
# Line 162  $sth->{hosts_by_name} = $dbh->prepare(qq Line 344  $sth->{hosts_by_name} = $dbh->prepare(qq
344  SELECT ID FROM hosts WHERE name=?  SELECT ID FROM hosts WHERE name=?
345  });  });
346    
347  $sth->{backups_broj} = $dbh->prepare(qq{  $sth->{backups_count} = $dbh->prepare(qq{
348  SELECT COUNT(*)  SELECT COUNT(*)
349  FROM backups  FROM backups
350  WHERE hostID=? AND num=?  WHERE hostID=? AND num=? AND shareid=?
351  });  });
352    
353  $sth->{insert_backups} = $dbh->prepare(qq{  $sth->{insert_backups} = $dbh->prepare(qq{
354  INSERT INTO backups (hostID, num, date, type)  INSERT INTO backups (hostID, num, date, type, shareid, size)
355  VALUES (?,?,?,?)  VALUES (?,?,?,?,?,?)
356  });  });
357    
358  $sth->{insert_files} = $dbh->prepare(qq{  $sth->{insert_files} = $dbh->prepare(qq{
359  INSERT INTO files  INSERT INTO files
360          (shareID, backupNum, name, path, fullpath, date, type, size)          (shareID, backupNum, name, path, date, type, size)
361          VALUES (?,?,?,?,?,?,?,?)          VALUES (?,?,?,?,?,?,?)
362  });  });
363    
364  foreach my $host_key (keys %{$hosts}) {  foreach my $host_key (keys %{$hosts}) {
# Line 191  foreach my $host_key (keys %{$hosts}) { Line 373  foreach my $host_key (keys %{$hosts}) {
373                          $hosts->{$host_key}->{'ip'}                          $hosts->{$host_key}->{'ip'}
374                  );                  );
375    
376                  $hostID = $dbh->func('last_insert_rowid');                  $hostID = $dbh->last_insert_id(undef,undef,'hosts',undef);
377          }          }
378    
379          print("host ".$hosts->{$host_key}->{'host'}.": ");          print "host ".$hosts->{$host_key}->{'host'}.": ";
380    
381          # get backups for a host          # get backups for a host
382          my @backups = $bpc->BackupInfoRead($hostname);          my @backups = $bpc->BackupInfoRead($hostname);
383          print scalar @backups, " increments\n";          my $incs = scalar @backups;
384            print  "$incs increments\n";
385    
386          my $inc_nr = 0;          my $inc_nr = 0;
387            $beenThere = {};
388    
389          foreach my $backup (@backups) {          foreach my $backup (@backups) {
390    
# Line 210  foreach my $host_key (keys %{$hosts}) { Line 394  foreach my $host_key (keys %{$hosts}) {
394                  my $backupNum = $backup->{'num'};                  my $backupNum = $backup->{'num'};
395                  my @backupShares = ();                  my @backupShares = ();
396    
397                  print $hosts->{$host_key}->{'host'},                  printf("%-10s %2d/%-2d #%-2d %s %5s/%5s files (date: %s dur: %s)\n",
398                          "\t#$backupNum\t", $backup->{type} || '?', " ",                          $hosts->{$host_key}->{'host'},
399                          $backup->{nFilesNew} || '?', "/", $backup->{nFiles} || '?',                          $inc_nr, $incs, $backupNum,
400                          " files\n";                          $backup->{type} || '?',
401                            $backup->{nFilesNew} || '?', $backup->{nFiles} || '?',
402                  $sth->{backups_broj}->execute($hostID, $backupNum);                          strftime($t_fmt,localtime($backup->{startTime})),
403                  my ($broj) = $sth->{backups_broj}->fetchrow_array();                          fmt_time($backup->{endTime} - $backup->{startTime})
404                  next if ($broj > 0);                  );
405    
406                  my $files = BackupPC::View->new($bpc, $hostname, \@backups, 1);                  my $files = BackupPC::View->new($bpc, $hostname, \@backups, 1);
407                  foreach my $share ($files->shareList($backupNum)) {                  foreach my $share ($files->shareList($backupNum)) {
408    
409                          my $t = time();                          my $t = time();
410    
                         print strftime($t_fmt,localtime())," ", $share;  
411                          $shareID = getShareID($share, $hostID, $hostname);                          $shareID = getShareID($share, $hostID, $hostname);
412                                    
413                          my ($f, $nf, $d, $nd) = recurseDir($bpc, $hostname, $files, $backupNum, $share, "", $shareID);                          $sth->{backups_count}->execute($hostID, $backupNum, $shareID);
414                          printf(" %d/%d files %d/%d dirs [%.2f/s]\n",                          my ($count) = $sth->{backups_count}->fetchrow_array();
415                                  $nf, $f, $nd, $d,                          # skip if allready in database!
416                                  ( ($f+$d) / ((time() - $t) || 1) )                          next if ($count > 0);
417    
418                            # dump some log
419                            print curr_time," ", $share;
420    
421                            my ($f, $nf, $d, $nd, $size) = recurseDir($bpc, $hostname, $files, $backupNum, $share, "", $shareID);
422    
423                            $sth->{insert_backups}->execute(
424                                    $hostID,
425                                    $backupNum,
426                                    $backup->{'endTime'},
427                                    $backup->{'type'},
428                                    $shareID,
429                                    $size,
430                          );                          );
431    
432                            print " commit";
433                          $dbh->commit();                          $dbh->commit();
                 }  
434    
435                  $sth->{insert_backups}->execute(                          my $dur = (time() - $t) || 1;
436                          $hostID,                          printf(" %d/%d files %d/%d dirs %0.2f MB [%.2f/s dur: %s]\n",
437                          $backupNum,                                  $nf, $f, $nd, $d,
438                          $backup->{'endTime'},                                  ($size / 1024 / 1024),
439                          $backup->{'type'}                                  ( ($f+$d) / $dur ),
440                  );                                  fmt_time($dur)
441                  $dbh->commit();                          );
442    
443                            hest_update($hostID, $shareID, $backupNum);
444                    }
445    
446          }          }
447  }  }
# Line 249  undef $sth; Line 449  undef $sth;
449  $dbh->commit();  $dbh->commit();
450  $dbh->disconnect();  $dbh->disconnect();
451    
452    print "total duration: ",fmt_time(time() - $start_t),"\n";
453    
454  $pidfile->remove;  $pidfile->remove;
455    
456  sub getShareID() {  sub getShareID() {
# Line 275  sub getShareID() { Line 477  sub getShareID() {
477          $drop_down =~ s#//+#/#g;          $drop_down =~ s#//+#/#g;
478    
479          $sth->{insert_share}->execute($hostID,$share, $drop_down ,undef);          $sth->{insert_share}->execute($hostID,$share, $drop_down ,undef);
480          return $dbh->func('last_insert_rowid');                  return $dbh->last_insert_id(undef,undef,'shares',undef);
481  }  }
482    
483  sub found_in_db {  sub found_in_db {
484    
485          my ($shareID,undef,$name,$path,undef,$date,undef,$size) = @_;          my @data = @_;
486            shift @data;
487    
488            my ($key, $shareID,undef,$name,$path,$date,undef,$size) = @_;
489    
490            return $beenThere->{$key} if (defined($beenThere->{$key}));
491    
492          $sth->{file_in_db} ||= $dbh->prepare(qq{          $sth->{file_in_db} ||= $dbh->prepare(qq{
493                  SELECT count(*) FROM files                  SELECT 1 FROM files
494                  WHERE shareID = ? and                  WHERE shareID = ? and
495                          path = ? and                          path = ? and
                         name = ? and  
496                          date = ? and                          date = ? and
497                          size = ?                          size = ?
498                    LIMIT 1
499          });          });
500    
501          my @param = ($shareID,$path,$name,$date,$size);          my @param = ($shareID,$path,$date,$size);
502          $sth->{file_in_db}->execute(@param);          $sth->{file_in_db}->execute(@param);
503          my ($rows) = $sth->{file_in_db}->fetchrow_array();          my $rows = $sth->{file_in_db}->rows;
504  #       print STDERR ( $rows ? '+' : '-' ), join(" ",@param), "\n";          print STDERR "## found_in_db($shareID,$path,$date,$size) ",( $rows ? '+' : '-' ), join(" ",@param), "\n" if ($debug >= 3);
505    
506            $beenThere->{$key}++;
507    
508            $sth->{'insert_files'}->execute(@data) unless ($rows);
509          return $rows;          return $rows;
510  }  }
511    
# Line 308  sub recurseDir($$$$$$$$) { Line 519  sub recurseDir($$$$$$$$) {
519    
520          print STDERR "\nrecurse($hostname,$backupNum,$share,$dir,$shareID)\n" if ($debug >= 1);          print STDERR "\nrecurse($hostname,$backupNum,$share,$dir,$shareID)\n" if ($debug >= 1);
521    
522          my ($nr_files, $new_files, $nr_dirs, $new_dirs) = (0,0,0,0);          my ($nr_files, $new_files, $nr_dirs, $new_dirs, $size) = (0,0,0,0,0);
523    
524          { # scope          { # scope
525                  my @stack;                  my @stack;
526    
527                    print STDERR "# dirAttrib($backupNum, $share, $dir)\n" if ($debug >= 2);
528                  my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);                  my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);
529    
530                  # first, add all the entries in current directory                  # first, add all the entries in current directory
531                  foreach my $path_key (keys %{$filesInBackup}) {                  foreach my $path_key (keys %{$filesInBackup}) {
532                            print STDERR "# file ",Dumper($filesInBackup->{$path_key}),"\n" if ($debug >= 3);
533                          my @data = (                          my @data = (
534                                  $shareID,                                  $shareID,
535                                  $backupNum,                                  $backupNum,
536                                  $path_key,                                  $path_key,
537                                  $filesInBackup->{$path_key}->{'relPath'},                                  $filesInBackup->{$path_key}->{'relPath'},
                                 $filesInBackup->{$path_key}->{'fullPath'},  
         #                       $filesInBackup->{$path_key}->{'sharePathM'},  
538                                  $filesInBackup->{$path_key}->{'mtime'},                                  $filesInBackup->{$path_key}->{'mtime'},
539                                  $filesInBackup->{$path_key}->{'type'},                                  $filesInBackup->{$path_key}->{'type'},
540                                  $filesInBackup->{$path_key}->{'size'}                                  $filesInBackup->{$path_key}->{'size'}
# Line 337  sub recurseDir($$$$$$$$) { Line 548  sub recurseDir($$$$$$$$) {
548                                  $filesInBackup->{$path_key}->{'size'}                                  $filesInBackup->{$path_key}->{'size'}
549                          ));                          ));
550    
551                            my $found;
552                          if (! $beenThere->{$key} && ! found_in_db(@data)) {                          if (! defined($beenThere->{$key}) && ! ($found = found_in_db($key, @data)) ) {
553                                  print STDERR "# key: $key [", $beenThere->{$key},"]" if ($debug >= 2);                                  print STDERR "# key: $key [", $beenThere->{$key},"]" if ($debug >= 2);
554                                  $sth->{'insert_files'}->execute(@data);  
555                                  if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {                                  if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
556                                          $new_dirs++;                                          $new_dirs++ unless ($found);
557                                          print STDERR " dir\n" if ($debug >= 2);                                          print STDERR " dir\n" if ($debug >= 2);
558                                  } else {                                  } else {
559                                          $new_files++;                                          $new_files++ unless ($found);
560                                          print STDERR " file\n" if ($debug >= 2);                                          print STDERR " file\n" if ($debug >= 2);
561                                  }                                  }
562                                    $size += $filesInBackup->{$path_key}->{'size'} || 0;
563                          }                          }
                         $beenThere->{$key}++;  
564    
565                          if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {                          if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
566                                  $nr_dirs++;                                  $nr_dirs++;
# Line 373  sub recurseDir($$$$$$$$) { Line 584  sub recurseDir($$$$$$$$) {
584                  print STDERR "## STACK ",join(", ", @stack),"\n" if ($debug >= 2);                  print STDERR "## STACK ",join(", ", @stack),"\n" if ($debug >= 2);
585    
586                  while ( my $dir = shift @stack ) {                  while ( my $dir = shift @stack ) {
587                          my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID);                          my ($f,$nf,$d,$nd, $s) = recurseDir($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID);
588                          print STDERR "# $dir f: $f nf: $nf d: $d nd: $nd\n" if ($debug >= 1);                          print STDERR "# $dir f: $f nf: $nf d: $d nd: $nd\n" if ($debug >= 1);
589                          $nr_files += $f;                          $nr_files += $f;
590                          $new_files += $nf;                          $new_files += $nf;
591                          $nr_dirs += $d;                          $nr_dirs += $d;
592                          $new_dirs += $nd;                          $new_dirs += $nd;
593                            $size += $s;
594                  }                  }
595          }          }
596    
597          return ($nr_files, $new_files, $nr_dirs, $new_dirs);          return ($nr_files, $new_files, $nr_dirs, $new_dirs, $size);
598  }  }
599    
Legend:
Removed from v.44  
changed lines
  Added in v.95
  ViewVC Help
Powered by ViewVC 1.1.26