Annotation of /trunk/bin/BackupPC_updatedb

#!/usr/local/bin/perl -w

use strict;
use lib "__INSTALLDIR__/lib";

use DBI;
use BackupPC::Lib;
use BackupPC::View;
use Data::Dumper;
use Getopt::Std;
use Time::HiRes qw/time/;
use File::Pid;
use POSIX qw/strftime/;

use constant BPC_FTYPE_DIR => 5;

my $debug = 0;
$|=1;

my $pidfile = new File::Pid;

if (my $pid = $pidfile->running ) {
        die "$0 already running: $pid\n";
} elsif ($pidfile->pid ne $$) {
        $pidfile->remove;
        $pidfile = new File::Pid;
}
$pidfile->write;
print STDERR "$0 using pid ",$pidfile->pid," file ",$pidfile->file,"\n";

my $t_fmt = '%Y-%m-%d %H:%M:%S';

my $hosts;
my $bpc = BackupPC::Lib->new || die;
my %Conf = $bpc->Conf();
my $TopDir = $bpc->TopDir();
my $beenThere = {};

my $dsn = "dbi:SQLite:dbname=$TopDir/$Conf{SearchDB}";

my $dbh = DBI->connect($dsn, "", "", { RaiseError => 1, AutoCommit => 0 });

my %opt;

if ( !getopts("cdm:v:", \%opt ) ) {
        print STDERR <<EOF;
usage: $0 [-c|-d] [-m num] [-v|-v level]

Options:
        -c      create database on first use
        -d      delete database before import
        -m num  import just num increments for one host
        -v num  set verbosity (debug) level (default $debug)
EOF
        exit 1;
}

###################################create tables############################3

if ($opt{c}) {
        print "creating tables...\n";
      
        $dbh->do(qq{
                create table hosts (
                        ID      INTEGER         PRIMARY KEY,
                        name    VARCHAR(30)     NOT NULL,
                        IP      VARCHAR(15)
                );            
        });
              
        $dbh->do(qq{
                create table shares (
                        ID      INTEGER         PRIMARY KEY,
                        hostID  INTEGER         NOT NULL references hosts(id),
                        name    VARCHAR(30)     NOT NULL,
                        share   VARCHAR(200)    NOT NULL,
                        localpath VARCHAR(200)      
                );            
        });
        
        $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) 
                );            
        });

        $dbh->do(qq{
                create table dvds (
                        ID      INTEGER         PRIMARY KEY, 
                        num     INTEGER         NOT NULL,
                        name    VARCHAR(255)    NOT NULL,
                        mjesto  VARCHAR(255)
                );
        });

        $dbh->do(qq{     
                create table files (
                        ID      INTEGER         NOT NULL PRIMARY KEY,  
                        shareID INTEGER         NOT NULL references shares(id),
                        backupNum  INTEGER      NOT NULL references backups(num),
                        name       VARCHAR(255) NOT NULL,
                        path       VARCHAR(255) NOT NULL,
                        fullpath   VARCHAR(255) NOT NULL,
                        date       TIMESTAMP    NOT NULL,
                        type       INTEGER      NOT NULL,
                        size       INTEGER      NOT NULL,
                        dvdid      INTEGER      references dvds(id)     
                );
        });

        print "creating indexes...\n";

        foreach my $index (qw(
                hosts_name
                backups_hostID
                backups_num
                shares_hostID
                shares_name
                files_shareID
                files_path
                files_name
                files_date
                files_size
        )) {
                my ($table,$col) = split(/_/, $index);
                $dbh->do(qq{ create index $index on $table($col) });
        }


}

if ($opt{d}) {
        print "deleting ";
        foreach my $table (qw(hosts shares files dvds backups)) {
                print "$table ";
                $dbh->do(qq{ DELETE FROM $table });
        }
        print " done...\n";
}

if ($opt{v}) {
        print "Debug level at $opt{v}\n";
        $debug = $opt{v};
}

#################################INSERT VALUES#############################

# get hosts
$hosts = $bpc->HostInfoRead();
my $hostID;
my $shareID;

my $sth;

$sth->{insert_hosts} = $dbh->prepare(qq{
INSERT INTO hosts (name, IP) VALUES (?,?)
});

$sth->{hosts_by_name} = $dbh->prepare(qq{
SELECT ID FROM hosts WHERE name=?
});

$sth->{backups_broj} = $dbh->prepare(qq{
SELECT COUNT(*)
FROM backups
WHERE hostID=? AND num=?
});

$sth->{insert_backups} = $dbh->prepare(qq{
INSERT INTO backups (hostID, num, date, type)
VALUES (?,?,?,?)
});

$sth->{insert_files} = $dbh->prepare(qq{
INSERT INTO files
        (shareID, backupNum, name, path, fullpath, date, type, size)
        VALUES (?,?,?,?,?,?,?,?)
});

foreach my $host_key (keys %{$hosts}) {

        my $hostname = $hosts->{$host_key}->{'host'} || die "can't find host for $host_key";

        $sth->{hosts_by_name}->execute($hosts->{$host_key}->{'host'});

        unless (($hostID) = $sth->{hosts_by_name}->fetchrow_array()) {
                $sth->{insert_hosts}->execute(
                        $hosts->{$host_key}->{'host'},
                        $hosts->{$host_key}->{'ip'}
                );

                $hostID = $dbh->func('last_insert_rowid');
        }

        print("host ".$hosts->{$host_key}->{'host'}.": ");
 
        # get backups for a host
        my @backups = $bpc->BackupInfoRead($hostname);
        print scalar @backups, " increments\n";

        my $inc_nr = 0;

        foreach my $backup (@backups) {

                $inc_nr++;
                last if ($opt{m} && $inc_nr > $opt{m});

                my $backupNum = $backup->{'num'};
                my @backupShares = ();

                print $hosts->{$host_key}->{'host'},
                        "\t#$backupNum\t", $backup->{type} || '?', " ",
                        $backup->{nFilesNew} || '?', "/", $backup->{nFiles} || '?',
                        " files\n";

                $sth->{backups_broj}->execute($hostID, $backupNum);
                my ($broj) = $sth->{backups_broj}->fetchrow_array();
                next if ($broj > 0);

                my $files = BackupPC::View->new($bpc, $hostname, \@backups, 1);
                foreach my $share ($files->shareList($backupNum)) {

                        my $t = time();

                        print strftime($t_fmt,localtime())," ", $share;
                        $shareID = getShareID($share, $hostID, $hostname);
                
                        my ($f, $nf, $d, $nd) = recurseDir($bpc, $hostname, $files, $backupNum, $share, "", $shareID);
                        printf(" %d/%d files %d/%d dirs [%.2f/s]\n",
                                $nf, $f, $nd, $d,
                                ( ($f+$d) / ((time() - $t) || 1) )
                        );
                        $dbh->commit();
                }

                $sth->{insert_backups}->execute(
                        $hostID,
                        $backupNum,
                        $backup->{'endTime'},
                        $backup->{'type'}
                );
                $dbh->commit();

        }
}
undef $sth;
$dbh->commit();
$dbh->disconnect();

$pidfile->remove;

sub getShareID() {

        my ($share, $hostID, $hostname) = @_;

        $sth->{share_id} ||= $dbh->prepare(qq{
                SELECT ID FROM shares WHERE hostID=? AND name=?
        });

        $sth->{share_id}->execute($hostID,$share);

        my ($id) = $sth->{share_id}->fetchrow_array();

        return $id if (defined($id));

        $sth->{insert_share} ||= $dbh->prepare(qq{
                INSERT INTO shares 
                        (hostID,name,share,localpath) 
                VALUES (?,?,?,?)
        });

        my $drop_down = $hostname . '/' . $share;
        $drop_down =~ s#//+#/#g;

        $sth->{insert_share}->execute($hostID,$share, $drop_down ,undef);
        return $dbh->func('last_insert_rowid');         
}

sub found_in_db {

        my @data = @_;
        shift @data;

        my ($key, $shareID,undef,$name,$path,undef,$date,undef,$size) = @_;

        return $beenThere->{$key} if (defined($beenThere->{$key}));

        $sth->{file_in_db} ||= $dbh->prepare(qq{
                SELECT 1 FROM files
                WHERE shareID = ? and
                        path = ? and 
                        name = ? and
                        date = ? and
                        size = ?
        });

        my @param = ($shareID,$path,$name,$date,$size);
        $sth->{file_in_db}->execute(@param);
        my $rows = $sth->{file_in_db}->rows;
        print STDERR "## found_in_db ",( $rows ? '+' : '-' ), join(" ",@param), "\n" if ($debug >= 3);

        $beenThere->{$key}++;

        $sth->{'insert_files'}->execute(@data) unless ($rows);
        return $rows;
}

####################################################
# recursing through filesystem structure and       #
# and returning flattened files list               #
####################################################
sub recurseDir($$$$$$$$) {

        my ($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID) = @_;

        print STDERR "\nrecurse($hostname,$backupNum,$share,$dir,$shareID)\n" if ($debug >= 1);

        my ($nr_files, $new_files, $nr_dirs, $new_dirs) = (0,0,0,0);

        { # scope
                my @stack;

                print STDERR "# dirAttrib($backupNum, $share, $dir)\n" if ($debug >= 2);
                my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);

                # first, add all the entries in current directory
                foreach my $path_key (keys %{$filesInBackup}) {
                        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'}
                        ));


                        if (! defined($beenThere->{$key}) && ! found_in_db($key, @data)) {
                                print STDERR "# key: $key [", $beenThere->{$key},"]" if ($debug >= 2);

                                if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
                                        $new_dirs++;
                                        print STDERR " dir\n" if ($debug >= 2);
                                } else {
                                        $new_files++;
                                        print STDERR " file\n" if ($debug >= 2);
                                }
                        }

                        if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
                                $nr_dirs++;

                                my $full_path = $dir . '/' . $path_key;
                                push @stack, $full_path;
                                print STDERR "### store to stack: $full_path\n" if ($debug >= 3);

#                               my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $backups, $backupNum, $share, $path_key, $shareID) unless ($beenThere->{$key});
#
#                               $nr_files += $f;
#                               $new_files += $nf;
#                               $nr_dirs += $d;
#                               $new_dirs += $nd;

                        } else {
                                $nr_files++;
                        }
                }

                print STDERR "## STACK ",join(", ", @stack),"\n" if ($debug >= 2);

                while ( my $dir = shift @stack ) {
                        my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID);
                        print STDERR "# $dir f: $f nf: $nf d: $d nd: $nd\n" if ($debug >= 1);
                        $nr_files += $f;
                        $new_files += $nf;
                        $nr_dirs += $d;
                        $new_dirs += $nd;
                }
        }

        return ($nr_files, $new_files, $nr_dirs, $new_dirs);
}

1	dpavlin	14	#!/usr/local/bin/perl -w
2	dpavlin	6
3			use strict;
4	dpavlin	48	use lib "__INSTALLDIR__/lib";
5
6	dpavlin	6	use DBI;
7			use BackupPC::Lib;
8			use BackupPC::View;
9			use Data::Dumper;
10			use Getopt::Std;
11	dpavlin	37	use Time::HiRes qw/time/;
12	dpavlin	38	use File::Pid;
13	dpavlin	37	use POSIX qw/strftime/;
14	dpavlin	48
15	dpavlin	6	use constant BPC_FTYPE_DIR => 5;
16
17	dpavlin	30	my $debug = 0;
18	dpavlin	14	$\|=1;
19	dpavlin	6
20	dpavlin	38	my $pidfile = new File::Pid;
21
22			if (my $pid = $pidfile->running ) {
23			die "$0 already running: $pid\n";
24			} elsif ($pidfile->pid ne $$) {
25			$pidfile->remove;
26			$pidfile = new File::Pid;
27			}
28	dpavlin	39	$pidfile->write;
29			print STDERR "$0 using pid ",$pidfile->pid," file ",$pidfile->file,"\n";
30	dpavlin	38
31	dpavlin	37	my $t_fmt = '%Y-%m-%d %H:%M:%S';
32
33	dpavlin	6	my $hosts;
34			my $bpc = BackupPC::Lib->new \|\| die;
35			my %Conf = $bpc->Conf();
36			my $TopDir = $bpc->TopDir();
37	dpavlin	14	my $beenThere = {};
38	dpavlin	6
39	dpavlin	14	my $dsn = "dbi:SQLite:dbname=$TopDir/$Conf{SearchDB}";
40	dpavlin	6
41	dpavlin	14	my $dbh = DBI->connect($dsn, "", "", { RaiseError => 1, AutoCommit => 0 });
42
43	dpavlin	6	my %opt;
44
45	dpavlin	44	if ( !getopts("cdm:v:", \%opt ) ) {
46	dpavlin	6	print STDERR <<EOF;
47	dpavlin	44	usage: $0 [-c\|-d] [-m num] [-v\|-v level]
48	dpavlin	6
49			Options:
50	dpavlin	14	-c create database on first use
51			-d delete database before import
52			-m num import just num increments for one host
53	dpavlin	44	-v num set verbosity (debug) level (default $debug)
54	dpavlin	6	EOF
55			exit 1;
56			}
57
58			###################################create tables############################3
59
60	dpavlin	14	if ($opt{c}) {
61			print "creating tables...\n";
62	dpavlin	6
63	dpavlin	14	$dbh->do(qq{
64			create table hosts (
65			ID INTEGER PRIMARY KEY,
66			name VARCHAR(30) NOT NULL,
67			IP VARCHAR(15)
68	dpavlin	6	);
69	dpavlin	14	});
70	dpavlin	6
71	dpavlin	14	$dbh->do(qq{
72			create table shares (
73			ID INTEGER PRIMARY KEY,
74			hostID INTEGER NOT NULL references hosts(id),
75			name VARCHAR(30) NOT NULL,
76			share VARCHAR(200) NOT NULL,
77			localpath VARCHAR(200)
78	dpavlin	6	);
79	dpavlin	14	});
80	dpavlin	6
81	dpavlin	14	$dbh->do(qq{
82			create table backups (
83			hostID INTEGER NOT NULL references hosts(id),
84			num INTEGER NOT NULL,
85			date DATE,
86			type CHAR(1),
87			PRIMARY KEY(hostID, num)
88	dpavlin	6	);
89	dpavlin	14	});
90	dpavlin	6
91	dpavlin	14	$dbh->do(qq{
92			create table dvds (
93			ID INTEGER PRIMARY KEY,
94			num INTEGER NOT NULL,
95			name VARCHAR(255) NOT NULL,
96			mjesto VARCHAR(255)
97	dpavlin	6	);
98	dpavlin	14	});
99	dpavlin	6
100	dpavlin	14	$dbh->do(qq{
101			create table files (
102			ID INTEGER NOT NULL PRIMARY KEY,
103			shareID INTEGER NOT NULL references shares(id),
104	dpavlin	18	backupNum INTEGER NOT NULL references backups(num),
105	dpavlin	14	name VARCHAR(255) NOT NULL,
106			path VARCHAR(255) NOT NULL,
107			fullpath VARCHAR(255) NOT NULL,
108			date TIMESTAMP NOT NULL,
109			type INTEGER NOT NULL,
110			size INTEGER NOT NULL,
111			dvdid INTEGER references dvds(id)
112	dpavlin	6	);
113	dpavlin	14	});
114	dpavlin	6
115	dpavlin	14	print "creating indexes...\n";
116	dpavlin	6
117	dpavlin	14	foreach my $index (qw(
118			hosts_name
119			backups_hostID
120			backups_num
121			shares_hostID
122			shares_name
123			files_shareID
124			files_path
125			files_name
126			files_date
127			files_size
128			)) {
129			my ($table,$col) = split(/_/, $index);
130			$dbh->do(qq{ create index $index on $table($col) });
131			}
132
133
134			}
135
136			if ($opt{d}) {
137			print "deleting ";
138			foreach my $table (qw(hosts shares files dvds backups)) {
139			print "$table ";
140			$dbh->do(qq{ DELETE FROM $table });
141			}
142			print " done...\n";
143			}
144
145	dpavlin	32	if ($opt{v}) {
146			print "Debug level at $opt{v}\n";
147			$debug = $opt{v};
148			}
149
150	dpavlin	6	#################################INSERT VALUES#############################
151
152			# get hosts
153	dpavlin	8	$hosts = $bpc->HostInfoRead();
154	dpavlin	6	my $hostID;
155			my $shareID;
156
157	dpavlin	14	my $sth;
158	dpavlin	6
159	dpavlin	14	$sth->{insert_hosts} = $dbh->prepare(qq{
160			INSERT INTO hosts (name, IP) VALUES (?,?)
161			});
162	dpavlin	6
163	dpavlin	14	$sth->{hosts_by_name} = $dbh->prepare(qq{
164			SELECT ID FROM hosts WHERE name=?
165			});
166
167			$sth->{backups_broj} = $dbh->prepare(qq{
168			SELECT COUNT(*)
169			FROM backups
170			WHERE hostID=? AND num=?
171			});
172
173			$sth->{insert_backups} = $dbh->prepare(qq{
174			INSERT INTO backups (hostID, num, date, type)
175			VALUES (?,?,?,?)
176			});
177
178			$sth->{insert_files} = $dbh->prepare(qq{
179			INSERT INTO files
180			(shareID, backupNum, name, path, fullpath, date, type, size)
181			VALUES (?,?,?,?,?,?,?,?)
182			});
183
184			foreach my $host_key (keys %{$hosts}) {
185
186			my $hostname = $hosts->{$host_key}->{'host'} \|\| die "can't find host for $host_key";
187
188			$sth->{hosts_by_name}->execute($hosts->{$host_key}->{'host'});
189
190			unless (($hostID) = $sth->{hosts_by_name}->fetchrow_array()) {
191			$sth->{insert_hosts}->execute(
192			$hosts->{$host_key}->{'host'},
193			$hosts->{$host_key}->{'ip'}
194			);
195
196			$hostID = $dbh->func('last_insert_rowid');
197			}
198
199			print("host ".$hosts->{$host_key}->{'host'}.": ");
200	dpavlin	6
201	dpavlin	14	# get backups for a host
202			my @backups = $bpc->BackupInfoRead($hostname);
203			print scalar @backups, " increments\n";
204	dpavlin	6
205	dpavlin	14	my $inc_nr = 0;
206
207			foreach my $backup (@backups) {
208	dpavlin	40
209	dpavlin	14	$inc_nr++;
210			last if ($opt{m} && $inc_nr > $opt{m});
211
212			my $backupNum = $backup->{'num'};
213			my @backupShares = ();
214
215	dpavlin	40	print $hosts->{$host_key}->{'host'},
216	dpavlin	44	"\t#$backupNum\t", $backup->{type} \|\| '?', " ",
217	dpavlin	40	$backup->{nFilesNew} \|\| '?', "/", $backup->{nFiles} \|\| '?',
218			" files\n";
219	dpavlin	14
220			$sth->{backups_broj}->execute($hostID, $backupNum);
221			my ($broj) = $sth->{backups_broj}->fetchrow_array();
222			next if ($broj > 0);
223
224	dpavlin	34	my $files = BackupPC::View->new($bpc, $hostname, \@backups, 1);
225	dpavlin	14	foreach my $share ($files->shareList($backupNum)) {
226
227	dpavlin	37	my $t = time();
228
229			print strftime($t_fmt,localtime())," ", $share;
230	dpavlin	14	$shareID = getShareID($share, $hostID, $hostname);
231
232	dpavlin	35	my ($f, $nf, $d, $nd) = recurseDir($bpc, $hostname, $files, $backupNum, $share, "", $shareID);
233	dpavlin	37	printf(" %d/%d files %d/%d dirs [%.2f/s]\n",
234			$nf, $f, $nd, $d,
235			( ($f+$d) / ((time() - $t) \|\| 1) )
236			);
237	dpavlin	14	$dbh->commit();
238			}
239	dpavlin	29
240			$sth->{insert_backups}->execute(
241			$hostID,
242			$backupNum,
243			$backup->{'endTime'},
244			$backup->{'type'}
245			);
246			$dbh->commit();
247
248	dpavlin	6	}
249			}
250	dpavlin	14	undef $sth;
251	dpavlin	6	$dbh->commit();
252			$dbh->disconnect();
253
254	dpavlin	38	$pidfile->remove;
255
256	dpavlin	14	sub getShareID() {
257	dpavlin	6
258	dpavlin	14	my ($share, $hostID, $hostname) = @_;
259
260			$sth->{share_id} \|\|= $dbh->prepare(qq{
261			SELECT ID FROM shares WHERE hostID=? AND name=?
262			});
263
264			$sth->{share_id}->execute($hostID,$share);
265
266			my ($id) = $sth->{share_id}->fetchrow_array();
267
268			return $id if (defined($id));
269
270			$sth->{insert_share} \|\|= $dbh->prepare(qq{
271			INSERT INTO shares
272			(hostID,name,share,localpath)
273			VALUES (?,?,?,?)
274			});
275
276	dpavlin	25	my $drop_down = $hostname . '/' . $share;
277			$drop_down =~ s#//+#/#g;
278
279			$sth->{insert_share}->execute($hostID,$share, $drop_down ,undef);
280	dpavlin	14	return $dbh->func('last_insert_rowid');
281	dpavlin	6	}
282
283	dpavlin	14	sub found_in_db {
284
285	dpavlin	48	my @data = @_;
286			shift @data;
287	dpavlin	14
288	dpavlin	48	my ($key, $shareID,undef,$name,$path,undef,$date,undef,$size) = @_;
289
290			return $beenThere->{$key} if (defined($beenThere->{$key}));
291
292	dpavlin	14	$sth->{file_in_db} \|\|= $dbh->prepare(qq{
293	dpavlin	48	SELECT 1 FROM files
294	dpavlin	14	WHERE shareID = ? and
295			path = ? and
296			name = ? and
297			date = ? and
298			size = ?
299			});
300
301			my @param = ($shareID,$path,$name,$date,$size);
302			$sth->{file_in_db}->execute(@param);
303	dpavlin	48	my $rows = $sth->{file_in_db}->rows;
304	dpavlin	45	print STDERR "## found_in_db ",( $rows ? '+' : '-' ), join(" ",@param), "\n" if ($debug >= 3);
305	dpavlin	48
306			$beenThere->{$key}++;
307
308			$sth->{'insert_files'}->execute(@data) unless ($rows);
309	dpavlin	14	return $rows;
310	dpavlin	6	}
311
312			####################################################
313			# recursing through filesystem structure and #
314			# and returning flattened files list #
315			####################################################
316	dpavlin	14	sub recurseDir($$$$$$$$) {
317	dpavlin	6
318	dpavlin	35	my ($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID) = @_;
319	dpavlin	14
320	dpavlin	44	print STDERR "\nrecurse($hostname,$backupNum,$share,$dir,$shareID)\n" if ($debug >= 1);
321	dpavlin	29
322	dpavlin	14	my ($nr_files, $new_files, $nr_dirs, $new_dirs) = (0,0,0,0);
323
324	dpavlin	27	{ # scope
325	dpavlin	29	my @stack;
326	dpavlin	14
327	dpavlin	45	print STDERR "# dirAttrib($backupNum, $share, $dir)\n" if ($debug >= 2);
328	dpavlin	27	my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);
329	dpavlin	14
330	dpavlin	27	# first, add all the entries in current directory
331			foreach my $path_key (keys %{$filesInBackup}) {
332			my @data = (
333			$shareID,
334			$backupNum,
335			$path_key,
336			$filesInBackup->{$path_key}->{'relPath'},
337			$filesInBackup->{$path_key}->{'fullPath'},
338			# $filesInBackup->{$path_key}->{'sharePathM'},
339			$filesInBackup->{$path_key}->{'mtime'},
340			$filesInBackup->{$path_key}->{'type'},
341			$filesInBackup->{$path_key}->{'size'}
342			);
343
344			my $key = join(" ", (
345			$shareID,
346			$dir,
347			$path_key,
348			$filesInBackup->{$path_key}->{'mtime'},
349			$filesInBackup->{$path_key}->{'size'}
350			));
351
352
353	dpavlin	48	if (! defined($beenThere->{$key}) && ! found_in_db($key, @data)) {
354	dpavlin	30	print STDERR "# key: $key [", $beenThere->{$key},"]" if ($debug >= 2);
355	dpavlin	48
356	dpavlin	27	if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
357			$new_dirs++;
358	dpavlin	30	print STDERR " dir\n" if ($debug >= 2);
359	dpavlin	27	} else {
360			$new_files++;
361	dpavlin	30	print STDERR " file\n" if ($debug >= 2);
362	dpavlin	27	}
363			}
364
365	dpavlin	14	if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
366	dpavlin	27	$nr_dirs++;
367
368	dpavlin	29	my $full_path = $dir . '/' . $path_key;
369			push @stack, $full_path;
370	dpavlin	30	print STDERR "### store to stack: $full_path\n" if ($debug >= 3);
371	dpavlin	29
372	dpavlin	27	# my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $backups, $backupNum, $share, $path_key, $shareID) unless ($beenThere->{$key});
373			#
374			# $nr_files += $f;
375			# $new_files += $nf;
376			# $nr_dirs += $d;
377			# $new_dirs += $nd;
378
379	dpavlin	14	} else {
380	dpavlin	27	$nr_files++;
381	dpavlin	14	}
382			}
383
384	dpavlin	30	print STDERR "## STACK ",join(", ", @stack),"\n" if ($debug >= 2);
385	dpavlin	14
386	dpavlin	29	while ( my $dir = shift @stack ) {
387	dpavlin	35	my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID);
388	dpavlin	30	print STDERR "# $dir f: $f nf: $nf d: $d nd: $nd\n" if ($debug >= 1);
389	dpavlin	29	$nr_files += $f;
390			$new_files += $nf;
391			$nr_dirs += $d;
392			$new_dirs += $nd;
393			}
394	dpavlin	14	}
395
396			return ($nr_files, $new_files, $nr_dirs, $new_dirs);
397	dpavlin	6	}
398