/[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 15 by dpavlin, Mon Jul 11 00:07:25 2005 UTC revision 306 by dpavlin, Sat Jan 28 20:42:42 2006 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;
10  use Getopt::Std;  use Getopt::Std;
11    use Time::HiRes qw/time/;
12    use File::Pid;
13    use POSIX qw/strftime/;
14    use BackupPC::SearchLib;
15    use Cwd qw/abs_path/;
16    
17  use constant BPC_FTYPE_DIR => 5;  use constant BPC_FTYPE_DIR => 5;
18    use constant EST_CHUNK => 100000;
19    
20    # daylight saving time change offset for 1h
21    my $dst_offset = 60 * 60;
22    
23    my $debug = 0;
24  $|=1;  $|=1;
25    
26    my $start_t = time();
27    
28    my $pid_path = abs_path($0);
29    $pid_path =~ s/\W+/_/g;
30    
31    my $pidfile = new File::Pid({
32            file => "/tmp/$pid_path",
33    });
34    
35    if (my $pid = $pidfile->running ) {
36            die "$0 already running: $pid\n";
37    } elsif ($pidfile->pid ne $$) {
38            $pidfile->remove;
39            $pidfile = new File::Pid;
40    }
41    print STDERR "$0 using pid ",$pidfile->pid," file ",$pidfile->file,"\n";
42    $pidfile->write;
43    
44    my $t_fmt = '%Y-%m-%d %H:%M:%S';
45    
46  my $hosts;  my $hosts;
47  my $bpc = BackupPC::Lib->new || die;  my $bpc = BackupPC::Lib->new || die;
48  my %Conf = $bpc->Conf();  my %Conf = $bpc->Conf();
49  my $TopDir = $bpc->TopDir();  my $TopDir = $bpc->TopDir();
50  my $beenThere = {};  my $beenThere = {};
51    
52  my $dsn = "dbi:SQLite:dbname=$TopDir/$Conf{SearchDB}";  my $dsn = $Conf{SearchDSN} || die "Need SearchDSN in config.pl\n";
53    my $user = $Conf{SearchUser} || '';
54    
55  my $dbh = DBI->connect($dsn, "", "", { RaiseError => 1, AutoCommit => 0 });  my $index_node_url = $Conf{HyperEstraierIndex};
56    
57    my $dbh = DBI->connect($dsn, $user, "", { RaiseError => 1, AutoCommit => 0 });
58    
59  my %opt;  my %opt;
60    
61  if ( !getopts("cdm:", \%opt ) ) {  if ( !getopts("cdm:v:ijf", \%opt ) ) {
62          print STDERR <<EOF;          print STDERR <<EOF;
63  usage: $0 [-c|-d] [-m num]  usage: $0 [-c|-d] [-m num] [-v|-v level] [-i|-j|-f]
64    
65  Options:  Options:
66          -c      create database on first use          -c      create database on first use
67          -d      delete database before import          -d      delete database before import
68          -m num  import just num increments for one host          -m num  import just num increments for one host
69            -v num  set verbosity (debug) level (default $debug)
70            -i      update Hyper Estraier full text index
71            -j      update full text, don't check existing files
72            -f      don't do anything with full text index
73    
74    Option -j is variation on -i. It will allow faster initial creation
75    of full-text index from existing database.
76    
77    Option -f will create database which is out of sync with full text index. You
78    will have to re-run $0 with -i to fix it.
79    
80  EOF  EOF
81          exit 1;          exit 1;
82  }  }
83    
84  ###################################create tables############################3  if ($opt{v}) {
85            print "Debug level at $opt{v}\n";
86            $debug = $opt{v};
87    } elsif ($opt{f}) {
88            print "WARNING: disabling full-text index update. You need to re-run $0 -j !\n";
89            $index_node_url = undef;
90    }
91    
92    #---- subs ----
93    
94    sub fmt_time {
95            my $t = shift || return;
96            my $out = "";
97            my ($ss,$mm,$hh) = gmtime($t);
98            $out .= "${hh}h" if ($hh);
99            $out .= sprintf("%02d:%02d", $mm,$ss);
100            return $out;
101    }
102    
103    sub curr_time {
104            return strftime($t_fmt,localtime());
105    }
106    
107    my $hest_node;
108    
109    sub hest_update {
110    
111            my ($host_id, $share_id, $num) = @_;
112    
113            my $skip_check = $opt{j} && print STDERR "Skipping check for existing files -- this should be used only with initital import\n";
114    
115            unless (defined($index_node_url)) {
116                    print STDERR "HyperEstraier support not enabled in configuration\n";
117                    $index_node_url = 0;
118                    return;
119            }
120    
121            print curr_time," updating Hyper Estraier:";
122    
123            my $t = time();
124    
125            my $offset = 0;
126            my $added = 0;
127    
128            print " opening index $index_node_url";
129            if ($index_node_url) {
130                    $hest_node ||= Search::Estraier::Node->new(
131                            url => $index_node_url,
132                            user => 'admin',
133                            passwd => 'admin',
134                            croak_on_error => 1,
135                    );
136                    print " via node URL";
137            } else {
138                    die "don't know how to use Hyper Estraier Index $index_node_url";
139            }
140    
141            my $results = 0;
142    
143            do {
144    
145                    my $where = '';
146                    my @data;
147                    if (defined($host_id) && defined($share_id) && defined($num)) {
148                            $where = qq{
149                            WHERE
150                                    hosts.id = ? AND
151                                    shares.id = ? AND
152                                    files.backupnum = ?
153                            };
154                            @data = ( $host_id, $share_id, $num );
155                    }
156    
157                    my $limit = sprintf('LIMIT '.EST_CHUNK.' OFFSET %d', $offset);
158    
159                    my $sth = $dbh->prepare(qq{
160                            SELECT
161                                    files.id                        AS fid,
162                                    hosts.name                      AS hname,
163                                    shares.name                     AS sname,
164                                    -- shares.share                 AS sharename,
165                                    files.backupnum                 AS backupnum,
166                                    -- files.name                   AS filename,
167                                    files.path                      AS filepath,
168                                    files.date                      AS date,
169                                    files.type                      AS type,
170                                    files.size                      AS size,
171                                    files.shareid                   AS shareid,
172                                    backups.date                    AS backup_date
173                            FROM files
174                                    INNER JOIN shares       ON files.shareID=shares.ID
175                                    INNER JOIN hosts        ON hosts.ID = shares.hostID
176                                    INNER JOIN backups      ON backups.num = files.backupNum and backups.hostID = hosts.ID AND backups.shareID = shares.ID
177                            $where
178                            $limit
179                    });
180    
181                    $sth->execute(@data);
182                    $results = $sth->rows;
183    
184                    if ($results == 0) {
185                            print " - no new files\n";
186                            return;
187                    } else {
188                            print " - $results files: ";
189                    }
190    
191                    sub fmt_date {
192                            my $t = shift || return;
193                            my $iso = BackupPC::Lib::timeStamp($t);
194                            $iso =~ s/\s/T/;
195                            return $iso;
196                    }
197    
198                    while (my $row = $sth->fetchrow_hashref()) {
199    
200                            my $fid = $row->{'fid'} || die "no fid?";
201                            my $uri = 'file:///' . $fid;
202    
203                            unless ($skip_check) {
204                                    my $id = $hest_node->uri_to_id($uri);
205                                    next if ($id && $id == -1);
206                            }
207    
208                            # create a document object
209                            my $doc = Search::Estraier::Document->new;
210    
211                            # add attributes to the document object
212                            $doc->add_attr('@uri', $uri);
213    
214                            foreach my $c (@{ $sth->{NAME} }) {
215                                    print STDERR "attr $c = $row->{$c}\n" if ($debug > 2);
216                                    $doc->add_attr($c, $row->{$c}) if (defined($row->{$c}));
217                            }
218    
219                            #$doc->add_attr('@cdate', fmt_date($row->{'date'}));
220    
221                            # add the body text to the document object
222                            my $path = $row->{'filepath'};
223                            $doc->add_text($path);
224                            $path =~ s/(.)/$1 /g;
225                            $doc->add_hidden_text($path);
226    
227                            print STDERR $doc->dump_draft,"\n" if ($debug > 1);
228    
229                            # register the document object to the database
230                            if ($hest_node) {
231                                    $hest_node->put_doc($doc);
232                            } else {
233                                    die "not supported";
234                            }
235                            $added++;
236                    }
237    
238                    print " $added";
239    
240                    $offset += EST_CHUNK;
241    
242            } while ($results == EST_CHUNK);
243    
244            my $dur = (time() - $t) || 1;
245            printf(" [%.2f/s dur: %s]\n",
246                    ( $added / $dur ),
247                    fmt_time($dur)
248            );
249    }
250    
251    #---- /subs ----
252    
253    
254    ## update index ##
255    if ( ( $opt{i} || $opt{j} ) && !$opt{c} ) {
256            # update all
257            print "force update of Hyper Estraier index ";
258            print "by -i flag" if ($opt{i});
259            print "by -j flag" if ($opt{j});
260            print "\n";
261            hest_update();
262    }
263    
264    ## create tables ##
265  if ($opt{c}) {  if ($opt{c}) {
266            sub do_index {
267                    my $index = shift || return;
268                    my ($table,$col,$unique) = split(/:/, $index);
269                    $unique ||= '';
270                    $index =~ s/\W+/_/g;
271                    print "$index on $table($col)" . ( $unique ? "u" : "" ) . " ";
272                    $dbh->do(qq{ create $unique index $index on $table($col) });
273            }
274    
275          print "creating tables...\n";          print "creating tables...\n";
276          
277          $dbh->do(qq{          $dbh->do( qq{
278                  create table hosts (                  create table hosts (
279                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
280                          name    VARCHAR(30)     NOT NULL,                          name    VARCHAR(30)     NOT NULL,
281                          IP      VARCHAR(15)                          IP      VARCHAR(15)
282                  );                              );            
283          });  
                 
         $dbh->do(qq{  
284                  create table shares (                  create table shares (
285                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
286                          hostID  INTEGER         NOT NULL references hosts(id),                          hostID  INTEGER         NOT NULL references hosts(id),
287                          name    VARCHAR(30)     NOT NULL,                          name    VARCHAR(30)     NOT NULL,
288                          share   VARCHAR(200)    NOT NULL,                          share   VARCHAR(200)    NOT NULL
                         localpath VARCHAR(200)        
289                  );                              );            
         });  
           
         $dbh->do(qq{  
                 create table backups (  
                         hostID  INTEGER         NOT NULL references hosts(id),  
                         num     INTEGER         NOT NULL,  
                         date    DATE,  
                         type    CHAR(1),  
                         PRIMARY KEY(hostID, num)  
                 );              
         });  
290    
         $dbh->do(qq{  
291                  create table dvds (                  create table dvds (
292                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
293                          num     INTEGER         NOT NULL,                          num     INTEGER         NOT NULL,
294                          name    VARCHAR(255)    NOT NULL,                          name    VARCHAR(255)    NOT NULL,
295                          mjesto  VARCHAR(255)                          mjesto  VARCHAR(255)
296                  );                  );
         });  
297    
298          $dbh->do(qq{                      create table backups (
299                            id      serial,
300                            hostID  INTEGER         NOT NULL references hosts(id),
301                            num     INTEGER         NOT NULL,
302                            date    integer         NOT NULL,
303                            type    CHAR(4)         not null,
304                            shareID integer         not null references shares(id),
305                            size    bigint          not null,
306                            inc_size bigint         not null default -1,
307                            inc_deleted boolean     default false,
308                            parts   integer         not null default 1,
309                            PRIMARY KEY(id)
310                    );            
311    
312                  create table files (                  create table files (
313                          ID      INTEGER         NOT NULL PRIMARY KEY,                            ID              SERIAL,
314                          shareID INTEGER         NOT NULL references shares(id),                          shareID         INTEGER NOT NULL references shares(id),
315                          backupNum  INTEGER      NOT NULL references backups(id),                          backupNum       INTEGER NOT NULL,
316                          name       VARCHAR(255) NOT NULL,                          name            VARCHAR(255) NOT NULL,
317                          path       VARCHAR(255) NOT NULL,                          path            VARCHAR(255) NOT NULL,
318                          fullpath   VARCHAR(255) NOT NULL,                          date            integer NOT NULL,
319                          date       TIMESTAMP    NOT NULL,                          type            INTEGER NOT NULL,
320                          type       INTEGER      NOT NULL,                          size            bigint  NOT NULL,
321                          size       INTEGER      NOT NULL,                          primary key(id)
322                          dvdid      INTEGER      references dvds(id)                      );
323    
324                    create table archive (
325                            id              serial,
326                            dvd_nr          int not null,
327                            total_size      bigint default -1,
328                            note            text,
329                            username        varchar(20) not null,
330                            date            timestamp default now(),
331                            primary key(id)
332                    );      
333    
334                    create table archive_backup (
335                            archive_id      int not null references archive(id) on delete cascade,
336                            backup_id       int not null references backups(id),
337                            primary key(archive_id, backup_id)
338                    );
339    
340                    create table archive_burned (
341                            archive_id      int references archive(id),
342                            date            timestamp default now(),
343                            part            int not null default 1,
344                            copy            int not null default 1,
345                            iso_size bigint default -1
346                    );
347    
348                    create table backup_parts (
349                            id serial,
350                            backup_id int references backups(id),
351                            part_nr int not null check (part_nr > 0),
352                            tar_size bigint not null check (tar_size > 0),
353                            size bigint not null check (size > 0),
354                            md5 text not null,
355                            items int not null check (items > 0),
356                            date timestamp default now(),
357                            primary key(id)
358                  );                  );
359          });          });
360    
361          print "creating indexes...\n";          print "creating indexes: ";
362    
363          foreach my $index (qw(          foreach my $index (qw(
364                  hosts_name                  hosts:name
365                  backups_hostID                  backups:hostID
366                  backups_num                  backups:num
367                  shares_hostID                  backups:shareID
368                  shares_name                  shares:hostID
369                  files_shareID                  shares:name
370                  files_path                  files:shareID
371                  files_name                  files:path
372                  files_date                  files:name
373                  files_size                  files:date
374                    files:size
375                    archive:dvd_nr
376                    archive_burned:archive_id
377                    backup_parts:backup_id,part_nr
378          )) {          )) {
379                  my ($table,$col) = split(/_/, $index);                  do_index($index);
380                  $dbh->do(qq{ create index $index on $table($col) });          }
381    
382            print " creating sequence: ";
383            foreach my $seq (qw/dvd_nr/) {
384                    print "$seq ";
385                    $dbh->do( qq{ CREATE SEQUENCE $seq } );
386          }          }
387    
388    
389            print "...\n";
390    
391            $dbh->commit;
392    
393  }  }
394    
395    ## delete data before inseting ##
396  if ($opt{d}) {  if ($opt{d}) {
397          print "deleting ";          print "deleting ";
398          foreach my $table (qw(hosts shares files dvds backups)) {          foreach my $table (qw(files dvds backups shares hosts)) {
399                  print "$table ";                  print "$table ";
400                  $dbh->do(qq{ DELETE FROM $table });                  $dbh->do(qq{ DELETE FROM $table });
401          }          }
402          print " done...\n";          print " done...\n";
403    
404            $dbh->commit;
405  }  }
406    
407  #################################INSERT VALUES#############################  ## insert new values ##
408    
409  # get hosts  # get hosts
410  $hosts = $bpc->HostInfoRead();  $hosts = $bpc->HostInfoRead();
# Line 139  $sth->{hosts_by_name} = $dbh->prepare(qq Line 421  $sth->{hosts_by_name} = $dbh->prepare(qq
421  SELECT ID FROM hosts WHERE name=?  SELECT ID FROM hosts WHERE name=?
422  });  });
423    
424  $sth->{backups_broj} = $dbh->prepare(qq{  $sth->{backups_count} = $dbh->prepare(qq{
425  SELECT COUNT(*)  SELECT COUNT(*)
426  FROM backups  FROM backups
427  WHERE hostID=? AND num=?  WHERE hostID=? AND num=? AND shareid=?
428  });  });
429    
430  $sth->{insert_backups} = $dbh->prepare(qq{  $sth->{insert_backups} = $dbh->prepare(qq{
431  INSERT INTO backups (hostID, num, date, type)  INSERT INTO backups (hostID, num, date, type, shareid, size)
432  VALUES (?,?,?,?)  VALUES (?,?,?,?,?,-1)
433    });
434    
435    $sth->{update_backups_size} = $dbh->prepare(qq{
436    UPDATE backups SET size = ?
437    WHERE hostID = ? and num = ? and date = ? and type =? and shareid = ?
438  });  });
439    
440  $sth->{insert_files} = $dbh->prepare(qq{  $sth->{insert_files} = $dbh->prepare(qq{
441  INSERT INTO files  INSERT INTO files
442          (shareID, backupNum, name, path, fullpath, date, type, size)          (shareID, backupNum, name, path, date, type, size)
443          VALUES (?,?,?,?,?,?,?,?)          VALUES (?,?,?,?,?,?,?)
444  });  });
445    
446  foreach my $host_key (keys %{$hosts}) {  my @hosts = keys %{$hosts};
447    my $host_nr = 0;
448    
449    foreach my $host_key (@hosts) {
450    
451          my $hostname = $hosts->{$host_key}->{'host'} || die "can't find host for $host_key";          my $hostname = $hosts->{$host_key}->{'host'} || die "can't find host for $host_key";
452    
# Line 168  foreach my $host_key (keys %{$hosts}) { Line 458  foreach my $host_key (keys %{$hosts}) {
458                          $hosts->{$host_key}->{'ip'}                          $hosts->{$host_key}->{'ip'}
459                  );                  );
460    
461                  $hostID = $dbh->func('last_insert_rowid');                  $hostID = $dbh->last_insert_id(undef,undef,'hosts',undef);
462          }          }
463    
464          print("host ".$hosts->{$host_key}->{'host'}.": ");          $host_nr++;
465            print "host ", $hosts->{$host_key}->{'host'}, " [",
466                    $host_nr, "/", ($#hosts + 1), "]: ";
467    
468          # get backups for a host          # get backups for a host
469          my @backups = $bpc->BackupInfoRead($hostname);          my @backups = $bpc->BackupInfoRead($hostname);
470          print scalar @backups, " increments\n";          my $incs = scalar @backups;
471            print  "$incs increments\n";
472    
473          my $inc_nr = 0;          my $inc_nr = 0;
474            $beenThere = {};
475    
476          foreach my $backup (@backups) {          foreach my $backup (@backups) {
477    
478                  $inc_nr++;                  $inc_nr++;
479                  last if ($opt{m} && $inc_nr > $opt{m});                  last if ($opt{m} && $inc_nr > $opt{m});
480    
481                  my $backupNum = $backup->{'num'};                  my $backupNum = $backup->{'num'};
482                  my @backupShares = ();                  my @backupShares = ();
483    
484                  print $hosts->{$host_key}->{'host'},"\t#$backupNum\n";                  printf("%-10s %2d/%-2d #%-2d %s %5s/%5s files (date: %s dur: %s)\n",
485                            $hosts->{$host_key}->{'host'},
486                  $sth->{backups_broj}->execute($hostID, $backupNum);                          $inc_nr, $incs, $backupNum,
487                  my ($broj) = $sth->{backups_broj}->fetchrow_array();                          $backup->{type} || '?',
488                  next if ($broj > 0);                          $backup->{nFilesNew} || '?', $backup->{nFiles} || '?',
489                            strftime($t_fmt,localtime($backup->{startTime})),
490                  $sth->{insert_backups}->execute(                          fmt_time($backup->{endTime} - $backup->{startTime})
                         $hostID,  
                         $backupNum,  
                         $backup->{'endTime'},  
                         $backup->{'type'}  
491                  );                  );
                 $dbh->commit();  
492    
493                  my $files = BackupPC::View->new($bpc, $hostname, \@backups);                  my $files = BackupPC::View->new($bpc, $hostname, \@backups, 1);
494                  foreach my $share ($files->shareList($backupNum)) {                  foreach my $share ($files->shareList($backupNum)) {
495    
496                          print "\t$share";                          my $t = time();
497    
498                          $shareID = getShareID($share, $hostID, $hostname);                          $shareID = getShareID($share, $hostID, $hostname);
499                                    
500                          my ($f, $nf, $d, $nd) = recurseDir($bpc, $hostname, \@backups, $backupNum, $share, "", $shareID);                          $sth->{backups_count}->execute($hostID, $backupNum, $shareID);
501                          print " $nf/$f files $nd/$d dirs\n";                          my ($count) = $sth->{backups_count}->fetchrow_array();
502                          $dbh->commit();                          # skip if allready in database!
503                            next if ($count > 0);
504    
505                            # dump some log
506                            print curr_time," ", $share;
507    
508                            $sth->{insert_backups}->execute(
509                                    $hostID,
510                                    $backupNum,
511                                    $backup->{'endTime'},
512                                    substr($backup->{'type'},0,4),
513                                    $shareID,
514                            );
515    
516                            my ($f, $nf, $d, $nd, $size) = recurseDir($bpc, $hostname, $files, $backupNum, $share, "", $shareID);
517    
518                            eval {
519                                    $sth->{update_backups_size}->execute(
520                                            $size,
521                                            $hostID,
522                                            $backupNum,
523                                            $backup->{'endTime'},
524                                            substr($backup->{'type'},0,4),
525                                            $shareID,
526                                    );
527                                    print " commit";
528                                    $dbh->commit();
529                            };
530                            if ($@) {
531                                    print " rollback";
532                                    $dbh->rollback();
533                            }
534    
535                            my $dur = (time() - $t) || 1;
536                            printf(" %d/%d files %d/%d dirs %0.2f MB [%.2f/s dur: %s]\n",
537                                    $nf, $f, $nd, $d,
538                                    ($size / 1024 / 1024),
539                                    ( ($f+$d) / $dur ),
540                                    fmt_time($dur)
541                            );
542    
543                            hest_update($hostID, $shareID, $backupNum) if ($nf + $nd > 0);
544                  }                  }
545    
546          }          }
547  }  }
548  undef $sth;  undef $sth;
549  $dbh->commit();  $dbh->commit();
550  $dbh->disconnect();  $dbh->disconnect();
551    
552    print "total duration: ",fmt_time(time() - $start_t),"\n";
553    
554    $pidfile->remove;
555    
556  sub getShareID() {  sub getShareID() {
557    
558          my ($share, $hostID, $hostname) = @_;          my ($share, $hostID, $hostname) = @_;
# Line 232  sub getShareID() { Line 569  sub getShareID() {
569    
570          $sth->{insert_share} ||= $dbh->prepare(qq{          $sth->{insert_share} ||= $dbh->prepare(qq{
571                  INSERT INTO shares                  INSERT INTO shares
572                          (hostID,name,share,localpath)                          (hostID,name,share)
573                  VALUES (?,?,?,?)                  VALUES (?,?,?)
574          });          });
575    
576          $sth->{insert_share}->execute($hostID,$share, $hostname . $share,undef);          my $drop_down = $hostname . '/' . $share;
577          return $dbh->func('last_insert_rowid');                  $drop_down =~ s#//+#/#g;
578    
579            $sth->{insert_share}->execute($hostID,$share, $drop_down);
580            return $dbh->last_insert_id(undef,undef,'shares',undef);
581  }  }
582    
583  sub found_in_db {  sub found_in_db {
584    
585          my ($shareID,undef,$name,$path,undef,$date,undef,$size) = @_;          my @data = @_;
586            shift @data;
587    
588            my ($key, $shareID,undef,$name,$path,$date,undef,$size) = @_;
589    
590            return $beenThere->{$key} if (defined($beenThere->{$key}));
591    
592          $sth->{file_in_db} ||= $dbh->prepare(qq{          $sth->{file_in_db} ||= $dbh->prepare(qq{
593                  SELECT count(*) FROM files                  SELECT 1 FROM files
594                  WHERE shareID = ? and                  WHERE shareID = ? and
595                          path = ? and                          path = ? and
596                          name = ? and                          size = ? and
597                          date = ? and                          ( date = ? or date = ? or date = ? )
598                          size = ?                  LIMIT 1
599          });          });
600    
601          my @param = ($shareID,$path,$name,$date,$size);          my @param = ($shareID,$path,$size,$date, $date-$dst_offset, $date+$dst_offset);
602          $sth->{file_in_db}->execute(@param);          $sth->{file_in_db}->execute(@param);
603          my ($rows) = $sth->{file_in_db}->fetchrow_array();          my $rows = $sth->{file_in_db}->rows;
604  #       print STDERR ( $rows ? '+' : '-' ), join(" ",@param), "\n";          print STDERR "## found_in_db($shareID,$path,$date,$size) ",( $rows ? '+' : '-' ), join(" ",@param), "\n" if ($debug >= 3);
605    
606            $beenThere->{$key}++;
607    
608            $sth->{'insert_files'}->execute(@data) unless ($rows);
609          return $rows;          return $rows;
610  }  }
611    
# Line 266  sub found_in_db { Line 615  sub found_in_db {
615  ####################################################  ####################################################
616  sub recurseDir($$$$$$$$) {  sub recurseDir($$$$$$$$) {
617    
618          my ($bpc, $hostname, $backups, $backupNum, $share, $dir, $shareID) = @_;          my ($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID) = @_;
619    
620          my ($nr_files, $new_files, $nr_dirs, $new_dirs) = (0,0,0,0);          print STDERR "\nrecurse($hostname,$backupNum,$share,$dir,$shareID)\n" if ($debug >= 1);
621    
622          my $files = BackupPC::View->new($bpc, $hostname, $backups);                      my ($nr_files, $new_files, $nr_dirs, $new_dirs, $size) = (0,0,0,0,0);
         my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);  
623    
624          # first, add all the entries in current directory          { # scope
625          foreach my $path_key (keys %{$filesInBackup}) {                  my @stack;
                 my @data = (  
                         $shareID,  
                         $backupNum,  
                         $path_key,  
                         $filesInBackup->{$path_key}->{'relPath'},  
                         $filesInBackup->{$path_key}->{'fullPath'},  
 #                       $filesInBackup->{$path_key}->{'sharePathM'},  
                         $filesInBackup->{$path_key}->{'mtime'},  
                         $filesInBackup->{$path_key}->{'type'},  
                         $filesInBackup->{$path_key}->{'size'}  
                 );  
   
                 my $key = join(" ", (  
                         $shareID,  
                         $dir,  
                         $path_key,  
                         $filesInBackup->{$path_key}->{'mtime'},  
                         $filesInBackup->{$path_key}->{'size'}  
                 ));  
626    
627                    print STDERR "# dirAttrib($backupNum, $share, $dir)\n" if ($debug >= 2);
628                    my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);
629    
630                    # first, add all the entries in current directory
631                    foreach my $path_key (keys %{$filesInBackup}) {
632                            print STDERR "# file ",Dumper($filesInBackup->{$path_key}),"\n" if ($debug >= 3);
633                            my @data = (
634                                    $shareID,
635                                    $backupNum,
636                                    $path_key,
637                                    $filesInBackup->{$path_key}->{'relPath'},
638                                    $filesInBackup->{$path_key}->{'mtime'},
639                                    $filesInBackup->{$path_key}->{'type'},
640                                    $filesInBackup->{$path_key}->{'size'}
641                            );
642    
643                            my $key = join(" ", (
644                                    $shareID,
645                                    $dir,
646                                    $path_key,
647                                    $filesInBackup->{$path_key}->{'mtime'},
648                                    $filesInBackup->{$path_key}->{'size'}
649                            ));
650    
651                            my $key_dst_prev = join(" ", (
652                                    $shareID,
653                                    $dir,
654                                    $path_key,
655                                    $filesInBackup->{$path_key}->{'mtime'} - $dst_offset,
656                                    $filesInBackup->{$path_key}->{'size'}
657                            ));
658    
659                            my $key_dst_next = join(" ", (
660                                    $shareID,
661                                    $dir,
662                                    $path_key,
663                                    $filesInBackup->{$path_key}->{'mtime'} + $dst_offset,
664                                    $filesInBackup->{$path_key}->{'size'}
665                            ));
666    
667                            my $found;
668                            if (
669                                    ! defined($beenThere->{$key}) &&
670                                    ! defined($beenThere->{$key_dst_prev}) &&
671                                    ! defined($beenThere->{$key_dst_next}) &&
672                                    ! ($found = found_in_db($key, @data))
673                            ) {
674                                    print STDERR "# key: $key [", $beenThere->{$key},"]" if ($debug >= 2);
675    
676                                    if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
677                                            $new_dirs++ unless ($found);
678                                            print STDERR " dir\n" if ($debug >= 2);
679                                    } else {
680                                            $new_files++ unless ($found);
681                                            print STDERR " file\n" if ($debug >= 2);
682                                    }
683                                    $size += $filesInBackup->{$path_key}->{'size'} || 0;
684                            }
685    
                 if (! $beenThere->{$key} && ! found_in_db(@data)) {  
                         $sth->{'insert_files'}->execute(@data);  
 #                       print STDERR "$key\n";  
686                          if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {                          if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
687                                  $new_dirs++;                                  $nr_dirs++;
688    
689                                    my $full_path = $dir . '/' . $path_key;
690                                    push @stack, $full_path;
691                                    print STDERR "### store to stack: $full_path\n" if ($debug >= 3);
692    
693    #                               my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $backups, $backupNum, $share, $path_key, $shareID) unless ($beenThere->{$key});
694    #
695    #                               $nr_files += $f;
696    #                               $new_files += $nf;
697    #                               $nr_dirs += $d;
698    #                               $new_dirs += $nd;
699    
700                          } else {                          } else {
701                                  $new_files++;                                  $nr_files++;
702                          }                          }
703                  }                  }
                 $beenThere->{$key}++;  
704    
705                  if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {                  print STDERR "## STACK ",join(", ", @stack),"\n" if ($debug >= 2);
                         $nr_dirs++;  
   
                         my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $backups, $backupNum, $share, $path_key, $shareID);  
706    
707                    while ( my $dir = shift @stack ) {
708                            my ($f,$nf,$d,$nd, $s) = recurseDir($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID);
709                            print STDERR "# $dir f: $f nf: $nf d: $d nd: $nd\n" if ($debug >= 1);
710                          $nr_files += $f;                          $nr_files += $f;
711                          $new_files += $nf;                          $new_files += $nf;
712                          $nr_dirs += $d;                          $nr_dirs += $d;
713                          $new_dirs += $nd;                          $new_dirs += $nd;
714                            $size += $s;
                 } else {  
                         $nr_files++;  
715                  }                  }
716          }          }
717    
718          return ($nr_files, $new_files, $nr_dirs, $new_dirs);          return ($nr_files, $new_files, $nr_dirs, $new_dirs, $size);
719  }  }
720    
Legend:
Removed from v.15  
changed lines
  Added in v.306
  ViewVC Help
Powered by ViewVC 1.1.26