webpac/trunk2/all2all.pl

#!/usr/bin/perl -w

=head1 NAME

all2all.pl - basic script for all WebPAC needs

=cut

use strict;
use YAML;
use Carp;
use Getopt::Long;

use lib './lib';
use WebPAC;
use WebPAC::jsFind;
use WebPAC::Index;
use WebPAC::Tree;

# options which can be changed via command line
#
my $code_page = 'ISO-8859-2';
my ($limit_mfn, $start_mfn, $debug, $low_mem);
my $index_path = './out/index';

my $result = GetOptions(
        "code_page=s"   => \$code_page,
        "limit_mfn=i"   => \$limit_mfn,
        "start_mfn=i"   => \$start_mfn,
        "debug!"        => \$debug,
        "low_mem!"      => \$low_mem,
);

# create WebPAC object
#
my $webpac = new WebPAC(
        code_page => $code_page,
        limit_mfn => $limit_mfn,
        start_mfn => $start_mfn,
        debug => $debug,
        low_mem => $low_mem,
) || die;

my $log = $webpac->_get_logger() || die "can't get logger";

$log->debug("creating WebPAC::jsFind object");

my $index = new WebPAC::jsFind(
        index_path => $index_path,
        keys => 10,
) || die;

my $thes;

$|=1;

my $maxmfn = $webpac->open_isis(
        filename => shift @ARGV || '/data/hidra/THS/THS',
        lookup => [
        { 'key' => 'd:v900', 'val' => 'v250^a' },
#       { 'eval' => '"v901^a" eq "Podruèje"', 'key' => 'pa:v561^4:v562^4:v461^1', 'val' => 'v900' },
#       { 'eval '=> '"v901^a" eq "Mikrotezaurus"', 'key' => 'a:v561^4:v562^4:v461^1', 'val' => 'v900' },
#       { 'eval' => '"v901^a" eq "Deskriptor"', 'key' => 'a:v561^4:v562^4:v461^1', 'val' => 'v900' },
        { 'key' => 'a:v561^4:v562^4:v461^1', 'val' => 'v900' },
        { 'key' => '900_mfn:v900', 'val' => 'v000' },
        # tree structure
        { 'eval' => 'length("v251") == 2', 'key' => 'root:v251', 'val' => 'v900' },
        { 'eval' => '"v251"', 'key' => 'code:v900', 'val' => 'v561^4:v251' },
        ],
);

$log->debug("isis file ",$webpac->{'isis_filename'}," opened");

$log->info("rows: $maxmfn");

$webpac->open_import_xml(type => 'isis_hidra_ths');

if(1) { # XXX

while (my $rec = $webpac->fetch_rec) {

        my @ds = $webpac->data_structure($rec);

        if (0 && $log->is_debug) {
                $log->debug("rec = ",Dump($rec));
                $log->debug("ds = ",Dump(\@ds));
        }

        next if (! @ds);

        my $filename = $webpac->{'current_filename'} || $log->logdie("no current_filename in webpac object");

        if ($filename) {
                $webpac->output_file(
                        file => $filename,
                        template => 'html.tt',
                        data => \@ds,
                        headline => $webpac->{'headline'},
                );
        } else {
                print $webpac->output(
                        template => 'text.tt',
                        data => \@ds,
                        headline => $webpac->{'headline'},
                );
        }

        my $headline = $webpac->{'headline'};

        my $f = $filename;
        $f =~ s!out/!!;

        # save into index
        foreach my $ds (@ds) {
                next if (! $ds->{'swish'});

                $index->insert(
                        index_name => $ds->{'tag'},
                        path => $f,
                        headline => $headline,
                        words => join(" ",@{$ds->{'swish'}})
                );
        }

        # save into sorted index (thesaurus)
        foreach my $ds (@ds) {
                next if (! $ds->{'index'});

                $thes->{$ds->{'tag'}} ||= new WebPAC::Index;

                foreach my $h (@{$ds->{'index'}}) {
                        $thes->{$ds->{'tag'}}->insert(
                                headline => $h,
                                mfn => $webpac->mfn,
                        );
                }
        }

#       print Dump(\@ds);

}

foreach my $t (keys %{$thes}) {

        my @e = $thes->{$t}->elements;
        if (! @e) {
                $log->logwarn("no elements in sorted index $t?");
                next;
        }

        my $file = "./out/bfilter/$t.txt";
        $log->info("saving sorted index $t to '$file' [".scalar(@e)." elements]");

        $webpac->output_file(
                file => $file,
                template => 'index.tt',
                data => \@e,
                index_name => $t,
        );
}

if (0 && $log->is_debug) {
        $log->debug("lookup hash: ",Dump($webpac->{'lookup'}));
        $log->debug("data hash: ",Dump($webpac->{'data'}));
        foreach my $t (keys %{$thes}) {
                $log->debug("thesaurus $t hash: ",Dump($thes->{$t}));
        }
}

} # XXX if(0)

$log->debug("lookup hash: ",Dump($webpac->{'lookup'}));

$log->info("creating tree");

#
# define tree structure
#

my $l = $webpac->{'lookup'} || $log->logconfess("can't find lookup");

my @tree = ({
        # level 0
        code_arr        => sub { sort keys %{$l} },
        filter_code     => sub {
                                        my $t = shift;
                                        return $t if ($t =~ s/root://);
                                },
        lookup_v900     => sub { shift @{$l->{"root:".$_[0]}} },
        lookup_term     => sub { shift @{$l->{"d:".$_[1]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[1]}} },
        have_children   => sub { return $l->{"a:".$_[0]."::"} },
        have_children_at_level => sub {
                                my $l2 = shift;
                                my $l1 = substr($l2,0,1);
                                return(9, "a:$l1:$l2:" ) if ($l->{"a:$l1:$l2"});
                        },
        style           => 'display: none',
        },{
        # 1
        code_arr        => sub { @{$_[0]} },
        filter_code     => sub { shift },       # nop
        lookup_v900     => sub { shift @{$l->{"code:".$_[0]}} },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
        have_children   => sub { return $l->{"a:".$_[1].":"} },
        style           => 'display: none',
        },{
        # 2
        code_arr        => sub { @{$_[0]} },
        filter_code     => sub { shift },
        lookup_v900     => sub { shift },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
        have_children   => sub { return $l->{"a:".$_[2].":".$_[1]} },
        #style          => 'display: none',
        },{
        # 3 u¾i pojam
        code_arr        => sub { @{$_[0]} },
        filter_code     => sub { shift },
        lookup_v900     => sub {
                                my ($c,$p) = @_;
                                $p =~ s/^a:(..:....):.*$/$1/;
                                return "a:".$p.":".$c;
                        },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
        have_children   => sub { return $l->{$_[1]} },
        },{
        # 4
        code_arr        => sub { @{$_[0]} },
        filter_code     => sub { shift },
        lookup_v900     => sub {
                                my ($c,$p) = @_;
                                $p =~ s/^a:(..:....):.*$/$1/;
                                return "a:".$p.":".$c;
                        },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
        have_children   => sub { return $l->{$_[1]} },
        },{
        # 5
        code_arr        => sub { @{$_[0]} },
        filter_code     => sub { shift },
        lookup_v900     => sub {
                                my ($c,$p) = @_;
                                $p =~ s/^a:(..:....):.*$/$1/;
                                return "a:".$p.":".$c;
                        },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
        have_children   => sub { return $l->{$_[1]} },
        },{
        # 6
        code_arr        => sub { @{$_[0]} },
        filter_code     => sub { shift },
        lookup_v900     => sub {
                                my ($c,$p) = @_;
                                $p =~ s/^a:(..:....):.*$/$1/;
                                return "a:".$p.":".$c;
                        },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
        have_children   => sub { return $l->{$_[1]} },
        },{
        # 7
        code_arr        => sub { @{$_[0]} },
        filter_code     => sub { shift },
        lookup_v900     => sub {
                                my ($c,$p) = @_;
                                $p =~ s/^a:(..:....):.*$/$1/;
                                return "a:".$p.":".$c;
                        },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
        have_children   => sub { return $l->{$_[1]} },
        },{
        # 8
        code_arr        => sub { @{$_[0]} },
        filter_code     => sub { shift },
        lookup_v900     => sub {
                                my ($c,$p) = @_;
                                $p =~ s/^a:(..:....):.*$/$1/;
                                return "a:".$p.":".$c;
                        },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
#       have_children   => sub { return $l->{$_[1]} },
#       child_code      => sub { return $_[1] },
        have_children   => sub { 0 },
        },{
        # 9 - level which is never reached except explicitly
        code_arr        => sub { @{$l->{$_[0]}} },
        filter_code     => sub { shift },
        lookup_v900     => sub {
                                my ($c,$p) = @_;
                                $p =~ s/^a:(.+:.+):.*$/$1/;
                                return "a:".$p.":".$c;
                        },
        lookup_term     => sub { shift @{$l->{"d:".$_[0]}} },
        lookup_mfn      => sub { shift @{$l->{"900_mfn:".$_[0]}} },
        have_children   => sub { 0 },
        have_children_at_level => sub { defined($l->{$_[1]}) && return (9,$_[1]) },
        },{
});

my $tree = new WebPAC::Tree(
        dir => './out',
        html => 'browse.html',
        template => './output_template/tree.tt',
        js => 'tree-ids.js',
        tree => \@tree,
);

$log->info("closing index");
$index->close;

$log->info("elapsed time: ",$webpac->fmt_time(time() - $webpac->{'start_t'}));
1	dpavlin	1	#!/usr/bin/perl -w
2
3	dpavlin	348	=head1 NAME
4
5	dpavlin	354	all2all.pl - basic script for all WebPAC needs
6	dpavlin	348
7			=cut
8
9	dpavlin	1	use strict;
10	dpavlin	454	use YAML;
11	dpavlin	352	use Carp;
12	dpavlin	437	use Getopt::Long;
13	dpavlin	1
14	dpavlin	352	use lib './lib';
15	dpavlin	354	use WebPAC;
16	dpavlin	390	use WebPAC::jsFind;
17	dpavlin	410	use WebPAC::Index;
18	dpavlin	441	use WebPAC::Tree;
19	dpavlin	348
20	dpavlin	437	# options which can be changed via command line
21			#
22			my $code_page = 'ISO-8859-2';
23			my ($limit_mfn, $start_mfn, $debug, $low_mem);
24			my $index_path = './out/index';
25
26			my $result = GetOptions(
27			"code_page=s" => \$code_page,
28			"limit_mfn=i" => \$limit_mfn,
29			"start_mfn=i" => \$start_mfn,
30			"debug!" => \$debug,
31			"low_mem!" => \$low_mem,
32			);
33
34			# create WebPAC object
35			#
36	dpavlin	354	my $webpac = new WebPAC(
37	dpavlin	437	code_page => $code_page,
38			limit_mfn => $limit_mfn,
39			start_mfn => $start_mfn,
40			debug => $debug,
41			low_mem => $low_mem,
42	dpavlin	352	) \|\| die;
43
44	dpavlin	421	my $log = $webpac->_get_logger() \|\| die "can't get logger";
45	dpavlin	373
46	dpavlin	421	$log->debug("creating WebPAC::jsFind object");
47
48	dpavlin	390	my $index = new WebPAC::jsFind(
49	dpavlin	437	index_path => $index_path,
50	dpavlin	413	keys => 10,
51	dpavlin	390	) \|\| die;
52
53	dpavlin	410	my $thes;
54
55	dpavlin	10	$\|=1;
56	dpavlin	9
57	dpavlin	352	my $maxmfn = $webpac->open_isis(
58	dpavlin	357	filename => shift @ARGV \|\| '/data/hidra/THS/THS',
59	dpavlin	352	lookup => [
60	dpavlin	348	{ 'key' => 'd:v900', 'val' => 'v250^a' },
61	dpavlin	352	# { 'eval' => '"v901^a" eq "Podruèje"', 'key' => 'pa:v561^4:v562^4:v461^1', 'val' => 'v900' },
62			# { 'eval '=> '"v901^a" eq "Mikrotezaurus"', 'key' => 'a:v561^4:v562^4:v461^1', 'val' => 'v900' },
63			# { 'eval' => '"v901^a" eq "Deskriptor"', 'key' => 'a:v561^4:v562^4:v461^1', 'val' => 'v900' },
64			{ 'key' => 'a:v561^4:v562^4:v461^1', 'val' => 'v900' },
65	dpavlin	374	{ 'key' => '900_mfn:v900', 'val' => 'v000' },
66	dpavlin	419	# tree structure
67			{ 'eval' => 'length("v251") == 2', 'key' => 'root:v251', 'val' => 'v900' },
68			{ 'eval' => '"v251"', 'key' => 'code:v900', 'val' => 'v561^4:v251' },
69	dpavlin	352	],
70	dpavlin	54	);
71	dpavlin	3
72	dpavlin	421	$log->debug("isis file ",$webpac->{'isis_filename'}," opened");
73
74	dpavlin	372	$log->info("rows: $maxmfn");
75	dpavlin	170
76	dpavlin	363	$webpac->open_import_xml(type => 'isis_hidra_ths');
77
78	dpavlin	425	if(1) { # XXX
79	dpavlin	424
80	dpavlin	362	while (my $rec = $webpac->fetch_rec) {
81	dpavlin	358
82	dpavlin	370	my @ds = $webpac->data_structure($rec);
83	dpavlin	366
84	dpavlin	411	if (0 && $log->is_debug) {
85	dpavlin	454	$log->debug("rec = ",Dump($rec));
86			$log->debug("ds = ",Dump(\@ds));
87	dpavlin	372	}
88
89	dpavlin	374	next if (! @ds);
90	dpavlin	366
91	dpavlin	421	my $filename = $webpac->{'current_filename'} \|\| $log->logdie("no current_filename in webpac object");
92	dpavlin	374
93			if ($filename) {
94	dpavlin	411	$webpac->output_file(
95			file => $filename,
96	dpavlin	374	template => 'html.tt',
97			data => \@ds,
98	dpavlin	398	headline => $webpac->{'headline'},
99	dpavlin	374	);
100			} else {
101			print $webpac->output(
102			template => 'text.tt',
103			data => \@ds,
104	dpavlin	398	headline => $webpac->{'headline'},
105	dpavlin	374	);
106			}
107
108	dpavlin	398	my $headline = $webpac->{'headline'};
109	dpavlin	390
110	dpavlin	392	my $f = $filename;
111			$f =~ s!out/!!;
112
113	dpavlin	390	# save into index
114			foreach my $ds (@ds) {
115			next if (! $ds->{'swish'});
116
117			$index->insert(
118			index_name => $ds->{'tag'},
119	dpavlin	392	path => $f,
120	dpavlin	390	headline => $headline,
121			words => join(" ",@{$ds->{'swish'}})
122			);
123			}
124
125	dpavlin	410	# save into sorted index (thesaurus)
126			foreach my $ds (@ds) {
127			next if (! $ds->{'index'});
128
129			$thes->{$ds->{'tag'}} \|\|= new WebPAC::Index;
130
131	dpavlin	415	foreach my $h (@{$ds->{'index'}}) {
132			$thes->{$ds->{'tag'}}->insert(
133			headline => $h,
134	dpavlin	448	mfn => $webpac->mfn,
135	dpavlin	415	);
136			}
137	dpavlin	410	}
138
139	dpavlin	454	# print Dump(\@ds);
140	dpavlin	390
141	dpavlin	3	}
142
143	dpavlin	411	foreach my $t (keys %{$thes}) {
144
145			my @e = $thes->{$t}->elements;
146			if (! @e) {
147			$log->logwarn("no elements in sorted index $t?");
148			next;
149			}
150
151	dpavlin	415	my $file = "./out/bfilter/$t.txt";
152			$log->info("saving sorted index $t to '$file' [".scalar(@e)." elements]");
153	dpavlin	411
154			$webpac->output_file(
155	dpavlin	415	file => $file,
156	dpavlin	411	template => 'index.tt',
157			data => \@e,
158			index_name => $t,
159			);
160			}
161
162			if (0 && $log->is_debug) {
163	dpavlin	454	$log->debug("lookup hash: ",Dump($webpac->{'lookup'}));
164			$log->debug("data hash: ",Dump($webpac->{'data'}));
165	dpavlin	410	foreach my $t (keys %{$thes}) {
166	dpavlin	454	$log->debug("thesaurus $t hash: ",Dump($thes->{$t}));
167	dpavlin	410	}
168	dpavlin	372	}
169	dpavlin	390
170	dpavlin	424	} # XXX if(0)
171
172	dpavlin	454	$log->debug("lookup hash: ",Dump($webpac->{'lookup'}));
173	dpavlin	420
174	dpavlin	441	$log->info("creating tree");
175
176	dpavlin	419	#
177	dpavlin	441	# define tree structure
178	dpavlin	419	#
179
180	dpavlin	424	my $l = $webpac->{'lookup'} \|\| $log->logconfess("can't find lookup");
181	dpavlin	419
182	dpavlin	424	my @tree = ({
183			# level 0
184			code_arr => sub { sort keys %{$l} },
185			filter_code => sub {
186			my $t = shift;
187			return $t if ($t =~ s/root://);
188			},
189			lookup_v900 => sub { shift @{$l->{"root:".$_[0]}} },
190			lookup_term => sub { shift @{$l->{"d:".$_[1]}} },
191			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[1]}} },
192	dpavlin	454	have_children => sub { return $l->{"a:".$_[0]."::"} },
193			have_children_at_level => sub {
194			my $l2 = shift;
195			my $l1 = substr($l2,0,1);
196			return(9, "a:$l1:$l2:" ) if ($l->{"a:$l1:$l2"});
197			},
198	dpavlin	424	style => 'display: none',
199			},{
200			# 1
201	dpavlin	454	code_arr => sub { @{$_[0]} },
202	dpavlin	424	filter_code => sub { shift }, # nop
203			lookup_v900 => sub { shift @{$l->{"code:".$_[0]}} },
204			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
205			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
206	dpavlin	454	have_children => sub { return $l->{"a:".$_[1].":"} },
207	dpavlin	424	style => 'display: none',
208			},{
209			# 2
210	dpavlin	454	code_arr => sub { @{$_[0]} },
211	dpavlin	424	filter_code => sub { shift },
212			lookup_v900 => sub { shift },
213			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
214			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
215	dpavlin	454	have_children => sub { return $l->{"a:".$_[2].":".$_[1]} },
216			#style => 'display: none',
217	dpavlin	425	},{
218			# 3 u¾i pojam
219	dpavlin	454	code_arr => sub { @{$_[0]} },
220	dpavlin	425	filter_code => sub { shift },
221	dpavlin	426	lookup_v900 => sub {
222			my ($c,$p) = @_;
223			$p =~ s/^a:(..:....):.*$/$1/;
224			return "a:".$p.":".$c;
225			},
226			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
227			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
228	dpavlin	454	have_children => sub { return $l->{$_[1]} },
229	dpavlin	426	},{
230			# 4
231	dpavlin	454	code_arr => sub { @{$_[0]} },
232	dpavlin	426	filter_code => sub { shift },
233			lookup_v900 => sub {
234			my ($c,$p) = @_;
235			$p =~ s/^a:(..:....):.*$/$1/;
236			return "a:".$p.":".$c;
237			},
238			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
239			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
240	dpavlin	454	have_children => sub { return $l->{$_[1]} },
241	dpavlin	427	},{
242			# 5
243	dpavlin	454	code_arr => sub { @{$_[0]} },
244	dpavlin	427	filter_code => sub { shift },
245			lookup_v900 => sub {
246			my ($c,$p) = @_;
247			$p =~ s/^a:(..:....):.*$/$1/;
248			return "a:".$p.":".$c;
249			},
250			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
251			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
252	dpavlin	454	have_children => sub { return $l->{$_[1]} },
253	dpavlin	427	},{
254			# 6
255	dpavlin	454	code_arr => sub { @{$_[0]} },
256	dpavlin	427	filter_code => sub { shift },
257			lookup_v900 => sub {
258			my ($c,$p) = @_;
259			$p =~ s/^a:(..:....):.*$/$1/;
260			return "a:".$p.":".$c;
261			},
262			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
263			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
264	dpavlin	454	have_children => sub { return $l->{$_[1]} },
265	dpavlin	427	},{
266			# 7
267	dpavlin	454	code_arr => sub { @{$_[0]} },
268	dpavlin	427	filter_code => sub { shift },
269			lookup_v900 => sub {
270			my ($c,$p) = @_;
271			$p =~ s/^a:(..:....):.*$/$1/;
272			return "a:".$p.":".$c;
273			},
274			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
275			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
276	dpavlin	454	have_children => sub { return $l->{$_[1]} },
277	dpavlin	427	},{
278			# 8
279	dpavlin	454	code_arr => sub { @{$_[0]} },
280	dpavlin	427	filter_code => sub { shift },
281			lookup_v900 => sub {
282			my ($c,$p) = @_;
283			$p =~ s/^a:(..:....):.*$/$1/;
284			return "a:".$p.":".$c;
285			},
286			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
287			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
288	dpavlin	454	# have_children => sub { return $l->{$_[1]} },
289	dpavlin	426	# child_code => sub { return $_[1] },
290	dpavlin	424	have_children => sub { 0 },
291	dpavlin	454	},{
292			# 9 - level which is never reached except explicitly
293			code_arr => sub { @{$l->{$_[0]}} },
294			filter_code => sub { shift },
295			lookup_v900 => sub {
296			my ($c,$p) = @_;
297			$p =~ s/^a:(.+:.+):.*$/$1/;
298			return "a:".$p.":".$c;
299			},
300			lookup_term => sub { shift @{$l->{"d:".$_[0]}} },
301			lookup_mfn => sub { shift @{$l->{"900_mfn:".$_[0]}} },
302			have_children => sub { 0 },
303			have_children_at_level => sub { defined($l->{$_[1]}) && return (9,$_[1]) },
304			},{
305	dpavlin	424	});
306	dpavlin	419
307	dpavlin	441	my $tree = new WebPAC::Tree(
308			dir => './out',
309			html => 'browse.html',
310			template => './output_template/tree.tt',
311			js => 'tree-ids.js',
312			tree => \@tree,
313			);
314	dpavlin	428
315			$log->info("closing index");
316	dpavlin	390	$index->close;
317
318	dpavlin	422	$log->info("elapsed time: ",$webpac->fmt_time(time() - $webpac->{'start_t'}));