Annotation of /trunk/bin/BackupPC_updatedb

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

use strict;
use DBI;
use lib "__INSTALLDIR__/lib";
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 ($shareID,undef,$name,$path,undef,$date,undef,$size) = @_;

        $sth->{file_in_db} ||= $dbh->prepare(qq{
                SELECT count(*) 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}->fetchrow_array();
        print STDERR "## found_in_db ",( $rows ? '+' : '-' ), join(" ",@param), "\n" if ($debug >= 3);
        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 (! $beenThere->{$key} && ! found_in_db(@data)) {
                                print STDERR "# key: $key [", $beenThere->{$key},"]" if ($debug >= 2);
                                $sth->{'insert_files'}->execute(@data);
                                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);
                                }
                        }
                        $beenThere->{$key}++;

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