/[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 27 by dpavlin, Fri Jul 29 17:31:14 2005 UTC revision 66 by dpavlin, Mon Aug 22 00:09:59 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;
10  use Getopt::Std;  use Getopt::Std;
11    use Time::HiRes qw/time/;
12    use File::Pid;
13    use POSIX qw/strftime/;
14    
15  use constant BPC_FTYPE_DIR => 5;  use constant BPC_FTYPE_DIR => 5;
16    
17    my $debug = 0;
18  $|=1;  $|=1;
19    
20    my $start_t = time();
21    
22    my $pidfile = new File::Pid;
23    
24    if (my $pid = $pidfile->running ) {
25            die "$0 already running: $pid\n";
26    } elsif ($pidfile->pid ne $$) {
27            $pidfile->remove;
28            $pidfile = new File::Pid;
29    }
30    $pidfile->write;
31    print STDERR "$0 using pid ",$pidfile->pid," file ",$pidfile->file,"\n";
32    
33    my $t_fmt = '%Y-%m-%d %H:%M:%S';
34    
35  my $hosts;  my $hosts;
36  my $bpc = BackupPC::Lib->new || die;  my $bpc = BackupPC::Lib->new || die;
37  my %Conf = $bpc->Conf();  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    
44  my $dbh = DBI->connect($dsn, "", "", { RaiseError => 1, AutoCommit => 0 });  my $dbh = DBI->connect($dsn, $user, "", { RaiseError => 1, AutoCommit => 0 });
45    
46  my %opt;  my %opt;
47    
48  if ( !getopts("cdm:", \%opt ) ) {  if ( !getopts("cdm:v:", \%opt ) ) {
49          print STDERR <<EOF;          print STDERR <<EOF;
50  usage: $0 [-c|-d] [-m num]  usage: $0 [-c|-d] [-m num] [-v|-v level]
51    
52  Options:  Options:
53          -c      create database on first use          -c      create database on first use
54          -d      delete database before import          -d      delete database before import
55          -m num  import just num increments for one host          -m num  import just num increments for one host
56            -v num  set verbosity (debug) level (default $debug)
57  EOF  EOF
58          exit 1;          exit 1;
59  }  }
# Line 38  EOF Line 61  EOF
61  ###################################create tables############################3  ###################################create tables############################3
62    
63  if ($opt{c}) {  if ($opt{c}) {
64            sub do_index {
65                    my $index = shift || return;
66                    my ($table,$col,$unique) = split(/_/, $index);
67                    $unique ||= '';
68                    $index =~ s/,/_/g;
69                    $dbh->do(qq{ create $unique index $index on $table($col) });
70            }
71    
72          print "creating tables...\n";          print "creating tables...\n";
73                
74          $dbh->do(qq{          $dbh->do(qq{
75                  create table hosts (                  create table hosts (
76                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
77                          name    VARCHAR(30)     NOT NULL,                          name    VARCHAR(30)     NOT NULL,
78                          IP      VARCHAR(15)                          IP      VARCHAR(15)
79                  );                              );            
# Line 50  if ($opt{c}) { Line 81  if ($opt{c}) {
81                                
82          $dbh->do(qq{          $dbh->do(qq{
83                  create table shares (                  create table shares (
84                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
85                          hostID  INTEGER         NOT NULL references hosts(id),                          hostID  INTEGER         NOT NULL references hosts(id),
86                          name    VARCHAR(30)     NOT NULL,                          name    VARCHAR(30)     NOT NULL,
87                          share   VARCHAR(200)    NOT NULL,                          share   VARCHAR(200)    NOT NULL,
# Line 62  if ($opt{c}) { Line 93  if ($opt{c}) {
93                  create table backups (                  create table backups (
94                          hostID  INTEGER         NOT NULL references hosts(id),                          hostID  INTEGER         NOT NULL references hosts(id),
95                          num     INTEGER         NOT NULL,                          num     INTEGER         NOT NULL,
96                          date    DATE,                          date    integer         NOT NULL,
97                          type    CHAR(1),                          type    CHAR(4)         not null,
98                          PRIMARY KEY(hostID, num)                          shareID integer         not null references shares(id),
99                            size    integer         not null,
100                            PRIMARY KEY(hostID, num, shareID)
101                  );                              );            
102          });          });
103    
104            #do_index('backups_hostid,num_unique');
105    
106          $dbh->do(qq{          $dbh->do(qq{
107                  create table dvds (                  create table dvds (
108                          ID      INTEGER         PRIMARY KEY,                          ID      SERIAL          PRIMARY KEY,
109                          num     INTEGER         NOT NULL,                          num     INTEGER         NOT NULL,
110                          name    VARCHAR(255)    NOT NULL,                          name    VARCHAR(255)    NOT NULL,
111                          mjesto  VARCHAR(255)                          mjesto  VARCHAR(255)
# Line 79  if ($opt{c}) { Line 114  if ($opt{c}) {
114    
115          $dbh->do(qq{              $dbh->do(qq{    
116                  create table files (                  create table files (
117                          ID      INTEGER         NOT NULL PRIMARY KEY,                            ID      SERIAL          PRIMARY KEY,  
118                          shareID INTEGER         NOT NULL references shares(id),                          shareID INTEGER         NOT NULL references shares(id),
119                          backupNum  INTEGER      NOT NULL references backups(num),                          backupNum  INTEGER      NOT NULL,
120                          name       VARCHAR(255) NOT NULL,                          name       VARCHAR(255) NOT NULL,
121                          path       VARCHAR(255) NOT NULL,                          path       VARCHAR(255) NOT NULL,
122                          fullpath   VARCHAR(255) NOT NULL,                          date       integer      NOT NULL,
                         date       TIMESTAMP    NOT NULL,  
123                          type       INTEGER      NOT NULL,                          type       INTEGER      NOT NULL,
124                          size       INTEGER      NOT NULL,                          size       INTEGER      NOT NULL,
125                          dvdid      INTEGER      references dvds(id)                              dvdid      INTEGER      references dvds(id)    
126                  );                  );
127          });          });
128    
129          print "creating indexes...\n";          print "creating indexes:";
130    
131          foreach my $index (qw(          foreach my $index (qw(
132                  hosts_name                  hosts_name
# Line 106  if ($opt{c}) { Line 140  if ($opt{c}) {
140                  files_date                  files_date
141                  files_size                  files_size
142          )) {          )) {
143                  my ($table,$col) = split(/_/, $index);                  print " $index";
144                  $dbh->do(qq{ create index $index on $table($col) });                  do_index($index);
145          }          }
146            print "...\n";
147    
148            $dbh->commit;
149    
150  }  }
151    
152  if ($opt{d}) {  if ($opt{d}) {
153          print "deleting ";          print "deleting ";
154          foreach my $table (qw(hosts shares files dvds backups)) {          foreach my $table (qw(files dvds backups shares hosts)) {
155                  print "$table ";                  print "$table ";
156                  $dbh->do(qq{ DELETE FROM $table });                  $dbh->do(qq{ DELETE FROM $table });
157          }          }
158          print " done...\n";          print " done...\n";
159    
160            $dbh->commit;
161    }
162    
163    if ($opt{v}) {
164            print "Debug level at $opt{v}\n";
165            $debug = $opt{v};
166  }  }
167    
168  #################################INSERT VALUES#############################  #################################INSERT VALUES#############################
# Line 139  $sth->{hosts_by_name} = $dbh->prepare(qq Line 182  $sth->{hosts_by_name} = $dbh->prepare(qq
182  SELECT ID FROM hosts WHERE name=?  SELECT ID FROM hosts WHERE name=?
183  });  });
184    
185  $sth->{backups_broj} = $dbh->prepare(qq{  $sth->{backups_count} = $dbh->prepare(qq{
186  SELECT COUNT(*)  SELECT COUNT(*)
187  FROM backups  FROM backups
188  WHERE hostID=? AND num=?  WHERE hostID=? AND num=? AND shareid=?
189  });  });
190    
191  $sth->{insert_backups} = $dbh->prepare(qq{  $sth->{insert_backups} = $dbh->prepare(qq{
192  INSERT INTO backups (hostID, num, date, type)  INSERT INTO backups (hostID, num, date, type, shareid, size)
193  VALUES (?,?,?,?)  VALUES (?,?,?,?,?,?)
194  });  });
195    
196  $sth->{insert_files} = $dbh->prepare(qq{  $sth->{insert_files} = $dbh->prepare(qq{
197  INSERT INTO files  INSERT INTO files
198          (shareID, backupNum, name, path, fullpath, date, type, size)          (shareID, backupNum, name, path, date, type, size)
199          VALUES (?,?,?,?,?,?,?,?)          VALUES (?,?,?,?,?,?,?)
200  });  });
201    
202    sub fmt_time {
203            my $t = shift || return;
204            my $out = "";
205            my ($ss,$mm,$hh) = gmtime($t);
206            $out .= "${hh}h" if ($hh);
207            $out .= sprintf("%02d:%02d", $mm,$ss);
208            return $out;
209    }
210    
211  foreach my $host_key (keys %{$hosts}) {  foreach my $host_key (keys %{$hosts}) {
212    
213          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";
# Line 168  foreach my $host_key (keys %{$hosts}) { Line 220  foreach my $host_key (keys %{$hosts}) {
220                          $hosts->{$host_key}->{'ip'}                          $hosts->{$host_key}->{'ip'}
221                  );                  );
222    
223                  $hostID = $dbh->func('last_insert_rowid');                  $hostID = $dbh->last_insert_id(undef,undef,'hosts',undef);
224          }          }
225    
226          print("host ".$hosts->{$host_key}->{'host'}.": ");          print("host ".$hosts->{$host_key}->{'host'}.": ");
# Line 180  foreach my $host_key (keys %{$hosts}) { Line 232  foreach my $host_key (keys %{$hosts}) {
232          my $inc_nr = 0;          my $inc_nr = 0;
233    
234          foreach my $backup (@backups) {          foreach my $backup (@backups) {
235    
236                  $inc_nr++;                  $inc_nr++;
237                  last if ($opt{m} && $inc_nr > $opt{m});                  last if ($opt{m} && $inc_nr > $opt{m});
238    
239                  my $backupNum = $backup->{'num'};                  my $backupNum = $backup->{'num'};
240                  my @backupShares = ();                  my @backupShares = ();
241    
242                  print $hosts->{$host_key}->{'host'},"\t#$backupNum\n";                  print $hosts->{$host_key}->{'host'},
243                            "\t#$backupNum\t", $backup->{type} || '?', " ",
244                            $backup->{nFilesNew} || '?', "/", $backup->{nFiles} || '?',
245                            " files (date: ",
246                            strftime($t_fmt,localtime($backup->{startTime})),
247                            " dur: ",
248                            fmt_time($backup->{endTime} - $backup->{startTime}),
249                            ")\n";
250    
251                  $sth->{backups_broj}->execute($hostID, $backupNum);                  my $files = BackupPC::View->new($bpc, $hostname, \@backups, 1);
                 my ($broj) = $sth->{backups_broj}->fetchrow_array();  
                 next if ($broj > 0);  
   
                 $sth->{insert_backups}->execute(  
                         $hostID,  
                         $backupNum,  
                         $backup->{'endTime'},  
                         $backup->{'type'}  
                 );  
                 $dbh->commit();  
   
                 my $files = BackupPC::View->new($bpc, $hostname, \@backups);  
252                  foreach my $share ($files->shareList($backupNum)) {                  foreach my $share ($files->shareList($backupNum)) {
253    
254                          print "\t$share";                          my $t = time();
255    
256                          $shareID = getShareID($share, $hostID, $hostname);                          $shareID = getShareID($share, $hostID, $hostname);
257                                    
258                          my ($f, $nf, $d, $nd) = recurseDir($bpc, $hostname, \@backups, $backupNum, $share, "", $shareID);                          $sth->{backups_count}->execute($hostID, $backupNum, $shareID);
259                          print " $nf/$f files $nd/$d dirs\n";                          my ($count) = $sth->{backups_count}->fetchrow_array();
260                            # skip if allready in database!
261                            next if ($count > 0);
262    
263                            # dump some log
264                            print strftime($t_fmt,localtime())," ", $share;
265    
266                            my ($f, $nf, $d, $nd, $size) = recurseDir($bpc, $hostname, $files, $backupNum, $share, "", $shareID);
267    
268                            $sth->{insert_backups}->execute(
269                                    $hostID,
270                                    $backupNum,
271                                    $backup->{'endTime'},
272                                    $backup->{'type'},
273                                    $shareID,
274                                    $size,
275                            );
276    
277                            print " commit";
278                          $dbh->commit();                          $dbh->commit();
279    
280                            my $dur = (time() - $t) || 1;
281                            printf(" %d/%d files %d/%d dirs %0.2f MB [%.2f/s dur: %s]\n",
282                                    $nf, $f, $nd, $d,
283                                    ($size / 1024 / 1024),
284                                    ( ($f+$d) / $dur ),
285                                    fmt_time($dur)
286                            );
287                  }                  }
288    
289          }          }
290  }  }
291  undef $sth;  undef $sth;
292  $dbh->commit();  $dbh->commit();
293  $dbh->disconnect();  $dbh->disconnect();
294    
295    print "total duration: ",fmt_time(time() - $start_t),"\n";
296    
297    $pidfile->remove;
298    
299  sub getShareID() {  sub getShareID() {
300    
301          my ($share, $hostID, $hostname) = @_;          my ($share, $hostID, $hostname) = @_;
# Line 240  sub getShareID() { Line 320  sub getShareID() {
320          $drop_down =~ s#//+#/#g;          $drop_down =~ s#//+#/#g;
321    
322          $sth->{insert_share}->execute($hostID,$share, $drop_down ,undef);          $sth->{insert_share}->execute($hostID,$share, $drop_down ,undef);
323          return $dbh->func('last_insert_rowid');                  return $dbh->last_insert_id(undef,undef,'shares',undef);
324  }  }
325    
326  sub found_in_db {  sub found_in_db {
327    
328          my ($shareID,undef,$name,$path,undef,$date,undef,$size) = @_;          my @data = @_;
329            shift @data;
330    
331            my ($key, $shareID,undef,$name,$path,undef,$date,undef,$size) = @_;
332    
333            return $beenThere->{$key} if (defined($beenThere->{$key}));
334    
335          $sth->{file_in_db} ||= $dbh->prepare(qq{          $sth->{file_in_db} ||= $dbh->prepare(qq{
336                  SELECT count(*) FROM files                  SELECT 1 FROM files
337                  WHERE shareID = ? and                  WHERE shareID = ? and
338                          path = ? and                          path = ? and
339                          name = ? and                          name = ? and
# Line 258  sub found_in_db { Line 343  sub found_in_db {
343    
344          my @param = ($shareID,$path,$name,$date,$size);          my @param = ($shareID,$path,$name,$date,$size);
345          $sth->{file_in_db}->execute(@param);          $sth->{file_in_db}->execute(@param);
346          my ($rows) = $sth->{file_in_db}->fetchrow_array();          my $rows = $sth->{file_in_db}->rows;
347  #       print STDERR ( $rows ? '+' : '-' ), join(" ",@param), "\n";          print STDERR "## found_in_db ",( $rows ? '+' : '-' ), join(" ",@param), "\n" if ($debug >= 3);
348    
349            $beenThere->{$key}++;
350    
351            $sth->{'insert_files'}->execute(@data) unless ($rows);
352          return $rows;          return $rows;
353  }  }
354    
# Line 269  sub found_in_db { Line 358  sub found_in_db {
358  ####################################################  ####################################################
359  sub recurseDir($$$$$$$$) {  sub recurseDir($$$$$$$$) {
360    
361          my ($bpc, $hostname, $backups, $backupNum, $share, $dir, $shareID) = @_;          my ($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID) = @_;
362    
363          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);
364    
365          my @stack;          my ($nr_files, $new_files, $nr_dirs, $new_dirs, $size) = (0,0,0,0,0);
366    
367          { # scope          { # scope
368                    my @stack;
369    
370                  my $files = BackupPC::View->new($bpc, $hostname, $backups);                              print STDERR "# dirAttrib($backupNum, $share, $dir)\n" if ($debug >= 2);
371                  my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);                  my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);
372    
 print STDERR "$hostname: $share | $dir | $backupNum\n";  
   
373                  # first, add all the entries in current directory                  # first, add all the entries in current directory
374                  foreach my $path_key (keys %{$filesInBackup}) {                  foreach my $path_key (keys %{$filesInBackup}) {
375                            print STDERR "# file ",Dumper($filesInBackup->{$path_key}),"\n" if ($debug >= 3);
376                          my @data = (                          my @data = (
377                                  $shareID,                                  $shareID,
378                                  $backupNum,                                  $backupNum,
379                                  $path_key,                                  $path_key,
380                                  $filesInBackup->{$path_key}->{'relPath'},                                  $filesInBackup->{$path_key}->{'relPath'},
                                 $filesInBackup->{$path_key}->{'fullPath'},  
         #                       $filesInBackup->{$path_key}->{'sharePathM'},  
381                                  $filesInBackup->{$path_key}->{'mtime'},                                  $filesInBackup->{$path_key}->{'mtime'},
382                                  $filesInBackup->{$path_key}->{'type'},                                  $filesInBackup->{$path_key}->{'type'},
383                                  $filesInBackup->{$path_key}->{'size'}                                  $filesInBackup->{$path_key}->{'size'}
# Line 305  print STDERR "$hostname: $share | $dir | Line 392  print STDERR "$hostname: $share | $dir |
392                          ));                          ));
393    
394    
395                          if (! $beenThere->{$key} && ! found_in_db(@data)) {                          if (! defined($beenThere->{$key}) && ! found_in_db($key, @data)) {
396                                  $sth->{'insert_files'}->execute(@data);                                  print STDERR "# key: $key [", $beenThere->{$key},"]" if ($debug >= 2);
397                                  print STDERR "$key\n";  
398                                  if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {                                  if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
399                                          $new_dirs++;                                          $new_dirs++;
400                                            print STDERR " dir\n" if ($debug >= 2);
401                                  } else {                                  } else {
402                                          $new_files++;                                          $new_files++;
403                                            print STDERR " file\n" if ($debug >= 2);
404                                  }                                  }
405                                    $size += $filesInBackup->{$path_key}->{'size'} || 0;
406                          }                          }
                         $beenThere->{$key}++;  
407    
408                          if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {                          if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
409                                  $nr_dirs++;                                  $nr_dirs++;
410    
411                                  push @stack, [ $bpc, $hostname, $backups, $backupNum, $share, $path_key, $shareID ] unless ($beenThere->{$key});                                  my $full_path = $dir . '/' . $path_key;
412                                    push @stack, $full_path;
413                                    print STDERR "### store to stack: $full_path\n" if ($debug >= 3);
414    
415  #                               my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $backups, $backupNum, $share, $path_key, $shareID) unless ($beenThere->{$key});  #                               my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $backups, $backupNum, $share, $path_key, $shareID) unless ($beenThere->{$key});
416  #  #
417  #                               $nr_files += $f;  #                               $nr_files += $f;
# Line 332  print STDERR "$hostname: $share | $dir | Line 424  print STDERR "$hostname: $share | $dir |
424                          }                          }
425                  }                  }
426    
427          }                  print STDERR "## STACK ",join(", ", @stack),"\n" if ($debug >= 2);
428    
429          foreach my $r (@stack) {                  while ( my $dir = shift @stack ) {
430                  my ($f,$nf,$d,$nd) = recurseDir(@{$r});                          my ($f,$nf,$d,$nd, $s) = recurseDir($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID);
431                  $nr_files += $f;                          print STDERR "# $dir f: $f nf: $nf d: $d nd: $nd\n" if ($debug >= 1);
432                  $new_files += $nf;                          $nr_files += $f;
433                  $nr_dirs += $d;                          $new_files += $nf;
434                  $new_dirs += $nd;                          $nr_dirs += $d;
435                            $new_dirs += $nd;
436                            $size += $s;
437                    }
438          }          }
439    
440          return ($nr_files, $new_files, $nr_dirs, $new_dirs);          return ($nr_files, $new_files, $nr_dirs, $new_dirs, $size);
441  }  }
442    
Legend:
Removed from v.27  
changed lines
  Added in v.66
  ViewVC Help
Powered by ViewVC 1.1.26