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]

Options:
        -c      create database on first use
        -d      delete database before import
        -m num  import just num increments for one host
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->{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 ( $rows ? '+' : '-' ), join(" ",@param), "\n";
        return $rows;
}

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

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

        print STDERR "recurse($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;

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