/[webpac2]/trunk/run.pl
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/run.pl

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 509 by dpavlin, Mon May 15 17:23:38 2006 UTC revision 814 by dpavlin, Sun Apr 1 21:47:48 2007 UTC
# Line 4  use strict; Line 4  use strict;
4    
5  use Cwd qw/abs_path/;  use Cwd qw/abs_path/;
6  use File::Temp qw/tempdir/;  use File::Temp qw/tempdir/;
 use Data::Dumper;  
7  use lib './lib';  use lib './lib';
8    
9  use WebPAC::Common 0.02;  use WebPAC::Common 0.02;
10  use WebPAC::Lookup;  use WebPAC::Parser 0.08;
11  use WebPAC::Input 0.03;  use WebPAC::Input 0.16;
12  use WebPAC::Store 0.03;  use WebPAC::Store 0.14;
13  use WebPAC::Normalize::XML;  use WebPAC::Normalize 0.22;
 use WebPAC::Normalize::Set;  
14  use WebPAC::Output::TT;  use WebPAC::Output::TT;
15  use YAML qw/LoadFile/;  use WebPAC::Validate 0.06;
16    use WebPAC::Output::MARC;
17    use WebPAC::Config;
18  use Getopt::Long;  use Getopt::Long;
19  use File::Path;  use File::Path;
20  use Time::HiRes qw/time/;  use Time::HiRes qw/time/;
21  use File::Slurp;  use File::Slurp;
22    use Data::Dump qw/dump/;
23    use Storable qw/dclone/;
24    use Pod::Usage qw/pod2usage/;
25    
26    use Proc::Queue size => 1;
27    use POSIX ":sys_wait_h"; # imports WNOHANG
28    
29  =head1 NAME  =head1 NAME
30    
# Line 26  run.pl - start WebPAC indexing Line 32  run.pl - start WebPAC indexing
32    
33  B<this command will probably go away. Don't get used to it!>  B<this command will probably go away. Don't get used to it!>
34    
35  Options:  =head1 OPTIONS
36    
37  =over 4  =over 4
38    
# Line 42  limit loading to 100 records Line 48  limit loading to 100 records
48    
49  remove database and Hyper Estraier index before indexing  remove database and Hyper Estraier index before indexing
50    
51  =item --only=database_name  =item --only=database_name/input_filter
52    
53  reindex just single database (legacy name is --one)  reindex just single database (legacy name is --one)
54    
55    C</input_filter> is optional part which can be C<name>
56    or C<type> from input
57    
58  =item --config conf/config.yml  =item --config conf/config.yml
59    
60  path to YAML configuration file  path to YAML configuration file
61    
62  =item --force-set  =item --stats
63    
64  force conversion C<< normalize->path >> in C<config.yml> from  disable indexing, modify_* in configuration and dump statistics about field
65  C<.xml> to C<.pl>  and subfield usage for each input
66    
67  =item --stats  =item --validate path/to/validation_file
68    
69    turn on extra validation of imput records, see L<WebPAC::Validation>
70    
71    =item --marc-generate
72    
73    Generate MARC file. This will automatically be on if file contains C<marc*> directives.
74    You can use this option as C<--no-marc-generate> to disable MARC generation.
75    
76    =item --marc-lint
77    
78    By default turned on if normalisation file has C<marc*> directives. You can disable lint
79    messages with C<--no-marc-lint>.
80    
81    =item --marc-dump
82    
83    Force dump or input and marc record for debugging.
84    
85    =item --parallel 4
86    
87    Run databases in parallel (aproximatly same as number of processors in
88    machine if you want to use full load)
89    
90    =item --only-links
91    
92    Create just links
93    
94    =item --merge
95    
96  disable indexing and dump statistics about field and subfield  Create merged index of databases which have links
 usage for each input  
97    
98  =back  =back
99    
# Line 68  my $offset; Line 103  my $offset;
103  my $limit;  my $limit;
104    
105  my $clean = 0;  my $clean = 0;
106  my $config = 'conf/config.yml';  my $config_path;
107  my $debug = 0;  my $debug = 0;
108  my $only_db_name;  my $only_filter;
 my $force_set = 0;  
109  my $stats = 0;  my $stats = 0;
110    my $validate_path;
111    my $marc_generate = 1;
112    my $marc_lint = 1;
113    my $marc_dump = 0;
114    my $parallel = 0;
115    my $only_links = 0;
116    my $merge = 0;
117    my $help;
118    
119    my $log = _new WebPAC::Common()->_get_logger();
120    
121  GetOptions(  GetOptions(
122          "limit=i" => \$limit,          "limit=i" => \$limit,
123          "offset=i" => \$offset,          "offset=i" => \$offset,
124          "clean" => \$clean,          "clean" => \$clean,
125          "one=s" => \$only_db_name,          "one=s" => \$only_filter,
126          "only=s" => \$only_db_name,          "only=s" => \$only_filter,
127          "config" => \$config,          "config" => \$config_path,
128          "debug" => \$debug,          "debug+" => \$debug,
         "force-set" => \$force_set,  
129          "stats" => \$stats,          "stats" => \$stats,
130            "validate=s" => \$validate_path,
131            "marc-generate!" => \$marc_generate,
132            "marc-lint!" => \$marc_lint,
133            "marc-dump!" => \$marc_dump,
134            "parallel=i" => \$parallel,
135            "only-links!" => \$only_links,
136            "merge" => \$merge,
137            "help" => \$help,
138  );  );
139    
140  $config = LoadFile($config);  pod2usage(-verbose => 2) if ($help);
141    
142  print "config = ",Dumper($config) if ($debug);  my $config = new WebPAC::Config( path => $config_path );
143    
144  die "no databases in config file!\n" unless ($config->{databases});  #print "config = ",dump($config) if ($debug);
145    
146    die "no databases in config file!\n" unless ($config->databases);
147    
 my $log = _new WebPAC::Common()->_get_logger();  
148  $log->info( "-" x 79 );  $log->info( "-" x 79 );
149    
150  my $use_indexer = $config->{use_indexer} || 'hyperestraier';  my $log_file = 'log';
151    
152    if (-e $log_file ) {    # && -s $log_file > 5 * 1024 * 1024) {
153            $log->info("moved old log with ", -s $log_file, " bytes to '${log_file}.old'");
154            rename $log_file, "${log_file}.old" || $log->logwarn("can't rename $log_file to ${log_file}.old: $!");
155    }
156    
157    my $estcmd_fh;
158    my $estcmd_path = './estcmd-merge.sh';
159    if ($merge) {
160            open($estcmd_fh, '>', $estcmd_path) || $log->logdie("can't open $estcmd_path: $!");
161            print $estcmd_fh 'cd /data/estraier/_node/ || exit 1',$/;
162            print $estcmd_fh 'sudo /etc/init.d/hyperestraier stop',$/;
163            $log->info("created merge batch file $estcmd_path");
164    }
165    
166    
167    my $validate;
168    $validate = new WebPAC::Validate(
169            path => $validate_path,
170    ) if ($validate_path);
171    
172    
173    my $use_indexer = $config->use_indexer;
174    $stats ||= $validate;
175  if ($stats) {  if ($stats) {
176          $log->debug("option --stats disables update of indexing engine...");          $log->debug("disabled indexing for stats collection");
177          $use_indexer = undef;          $use_indexer = undef;
178  } else {  } else {
179          $log->info("using $use_indexer indexing engine...");          $log->info("using $use_indexer indexing engine...");
180  }  }
181    
182    # parse normalize files and create source files for lookup and normalization
183    
184    my $parser = new WebPAC::Parser( config => $config );
185    
186  my $total_rows = 0;  my $total_rows = 0;
187  my $start_t = time();  my $start_t = time();
188    
189  while (my ($database, $db_config) = each %{ $config->{databases} }) {  my @links;
190    
191    if ($parallel) {
192            $log->info("Using $parallel processes for speedup");
193            Proc::Queue::size($parallel);
194    }
195    
196    sub create_ds_config {
197            my ($db_config, $database, $input, $mfn) = @_;
198            my $c = dclone( $db_config );
199            $c->{_} = $database || $log->logconfess("need database");
200            $c->{_mfn} = $mfn || $log->logconfess("need mfn");
201            $c->{input} = $input || $log->logconfess("need input");
202            return $c;
203    }
204    
205    while (my ($database, $db_config) = each %{ $config->databases }) {
206    
207            my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);
208            next if ($only_database && $database !~ m/$only_database/i);
209    
210          next if ($only_db_name && $database !~ m/$only_db_name/i);          if ($parallel) {
211                    my $f=fork;
212                    if(defined ($f) and $f==0) {
213                            $log->info("Created processes $$ for speedup");
214                    } else {
215                            next;
216                    }
217            }
218    
219          my $indexer;          my $indexer;
220            if ($use_indexer && $parser->have_rules( 'search', $database )) {
221    
222                    my $cfg_name = $use_indexer;
223                    $cfg_name =~ s/\-.*$//;
224    
225          if ($use_indexer) {                  my $indexer_config = $config->get( $cfg_name ) || $log->logdie("can't find '$cfg_name' part in confguration");
                 my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");  
226                  $indexer_config->{database} = $database;                  $indexer_config->{database} = $database;
227                  $indexer_config->{clean} = $clean;                  $indexer_config->{clean} = $clean;
228                  $indexer_config->{label} = $db_config->{name};                  $indexer_config->{label} = $db_config->{name};
229    
230                    # force clean if database has links
231                    $indexer_config->{clean} = 1 if ($db_config->{links});
232    
233                  if ($use_indexer eq 'hyperestraier') {                  if ($use_indexer eq 'hyperestraier') {
234    
235                          # open Hyper Estraier database                          # open Hyper Estraier database
236                          use WebPAC::Output::Estraier '0.10';                          use WebPAC::Output::Estraier '0.10';
237                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
238                                    
239                    } elsif ($use_indexer eq 'hyperestraier-native') {
240    
241                            # open Hyper Estraier database
242                            use WebPAC::Output::EstraierNative;
243                            $indexer = new WebPAC::Output::EstraierNative( %{ $indexer_config } );
244    
245                  } elsif ($use_indexer eq 'kinosearch') {                  } elsif ($use_indexer eq 'kinosearch') {
246    
247                          # open KinoSearch                          # open KinoSearch
# Line 140  while (my ($database, $db_config) = each Line 258  while (my ($database, $db_config) = each
258    
259    
260          #          #
261            # store Hyper Estraier links to other databases
262            #
263            if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {
264                    foreach my $link (@{ $db_config->{links} }) {
265                            if ($use_indexer eq 'hyperestraier') {
266                                    if ($merge) {
267                                            print $estcmd_fh 'sudo -u www-data estcmd merge ' . $database . ' ' . $link->{to},$/;
268                                    } else {
269                                            $log->info("saving link $database -> $link->{to} [$link->{credit}]");
270                                            push @links, sub {
271                                                    $log->info("adding link $database -> $link->{to} [$link->{credit}]");
272                                                    $indexer->add_link(
273                                                            from => $database,
274                                                            to => $link->{to},
275                                                            credit => $link->{credit},
276                                                    );
277                                            };
278                                    }
279                            } else {
280                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
281                            }
282                    }
283            }
284            next if ($only_links);
285    
286    
287            #
288          # now WebPAC::Store          # now WebPAC::Store
289          #          #
290          my $abs_path = abs_path($0);          my $abs_path = abs_path($0);
291          $abs_path =~ s#/[^/]*$#/#;          $abs_path =~ s#/[^/]*$#/#;
292    
293          my $db_path = $config->{webpac}->{db_path} . '/' . $database;          my $db_path = $config->webpac('db_path');
294    
295          if ($clean) {          if ($clean) {
296                  $log->info("creating new database $database in $db_path");                  $log->info("creating new database '$database' in $db_path");
297                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");
298          } else {          } else {
299                  $log->debug("working on $database in $db_path");                  $log->info("working on database '$database' in $db_path");
300          }          }
301    
302          my $db = new WebPAC::Store(          my $store = new WebPAC::Store(
303                  path => $db_path,                  path => $db_path,
                 database => $database,  
304                  debug => $debug,                  debug => $debug,
305          );          );
306    
# Line 174  while (my ($database, $db_config) = each Line 318  while (my ($database, $db_config) = each
318                  $log->info("database $database doesn't have inputs defined");                  $log->info("database $database doesn't have inputs defined");
319          }          }
320    
         my @supported_inputs = keys %{ $config->{webpac}->{inputs} };  
   
321          foreach my $input (@inputs) {          foreach my $input (@inputs) {
322    
323                    my $input_name = $input->{name} || $log->logdie("input without a name isn't valid: ",dump($input));
324    
325                    next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
326    
327                  my $type = lc($input->{type});                  my $type = lc($input->{type});
328    
329                  die "I know only how to handle input types ", join(",", @supported_inputs), " not '$type'!\n" unless (grep(/$type/, @supported_inputs));                  die "I know only how to handle input types ", join(",", $config->webpac('inputs') ), " not '$type'!\n" unless (grep(/$type/, $config->webpac('inputs')));
330    
331                  my $lookup = new WebPAC::Lookup(                  my $input_module = $config->webpac('inputs')->{$type};
332                          lookup_file => $input->{lookup},  
333                  );                  my @lookups = $parser->have_lookup_create($database, $input);
334    
335                  my $input_module = $config->{webpac}->{inputs}->{$type};                  $log->info("working on input '$input_name' in $input->{path} [type: $input->{type}] using $input_module",
336                            @lookups ? " creating lookups: ".join(", ", @lookups) : ""
337                    );
338    
339                  $log->info("working on input '$input->{path}' [$input->{type}] using $input_module lookup '$input->{lookup}'");                  if ($stats) {
340                            # disable modification of records if --stats is in use
341                            delete($input->{modify_records});
342                            delete($input->{modify_file});
343                    }
344    
345                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
346                          module => $input_module,                          module => $input_module,
347                          code_page => $config->{webpac}->{webpac_encoding},                          encoding => $config->webpac('webpac_encoding'),
348                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
349                          offset => $offset,                          offset => $offset,
                         lookup => $lookup,  
350                          recode => $input->{recode},                          recode => $input->{recode},
351                          stats => $stats,                          stats => $stats,
352                            modify_records => $input->{modify_records},
353                            modify_file => $input->{modify_file},
354                  );                  );
355                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
356    
357                    if (defined( $input->{lookup} )) {
358                            $log->warn("$database/$input_name has depriciated lookup definition, removing it...");
359                            delete( $input->{lookup} );
360                    }
361    
362                    my $lookup_coderef;
363    
364                    if (@lookups) {
365    
366                            my $rules = $parser->lookup_create_rules($database, $input) || $log->logdie("no rules found for $database/$input");
367    
368                            $lookup_coderef = sub {
369                                    my $rec = shift || die "need rec!";
370                                    my $mfn = $rec->{'000'}->[0] || die "need mfn in 000";
371    
372                                    WebPAC::Normalize::data_structure(
373                                            row => $rec,
374                                            rules => $rules,
375                                            config => create_ds_config( $db_config, $database, $input, $mfn ),
376                                    );
377    
378                                    #warn "current lookup: ", dump(WebPAC::Normalize::_get_lookup());
379                            };
380    
381                            WebPAC::Normalize::_set_lookup( undef );
382    
383                            $log->debug("created lookup_coderef using:\n$rules");
384    
385                    };
386    
387                    my $lookup_jar;
388    
389                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
390                          path => $input->{path},                          path => $input->{path},
391                          code_page => $input->{encoding},        # database encoding                          code_page => $input->{encoding},        # database encoding
392                  );                          lookup_coderef => $lookup_coderef,
393                            lookup => $lookup_jar,
394                            %{ $input },
395                            load_row => sub {
396                                    my $a = shift;
397                                    return $store->load_row(
398                                            database => $database,
399                                            input => $input_name,
400                                            id => $a->{id},
401                                    );
402                            },
403                            save_row => sub {
404                                    my $a = shift;
405                                    return $store->save_row(
406                                            database => $database,
407                                            input => $input_name,
408                                            id => $a->{id},
409                                            row => $a->{row},
410                                    );
411                            },
412    
                 my $n = new WebPAC::Normalize::XML(  
                 #       filter => { 'foo' => sub { shift } },  
                         db => $db,  
                         lookup_regex => $lookup->regex,  
                         lookup => $lookup,  
                         prefix => $input->{name},  
413                  );                  );
414    
415                  my $rules;                  my $lookup_data = WebPAC::Normalize::_get_lookup();
                 my $normalize_path = $input->{normalize}->{path};  
416    
417                  if ($force_set) {                  if (defined( $lookup_data->{$database}->{$input_name} )) {
418                          my $new_norm_path = $normalize_path;                          $log->debug("created following lookups: ", sub { dump( $lookup_data ) } );
419                          $new_norm_path =~ s/\.xml$/.pl/;  
420                          if (-e $new_norm_path) {                          foreach my $key (keys %{ $lookup_data->{$database}->{$input_name} }) {
421                                  $log->debug("--force-set replaced $normalize_path with $new_norm_path");                                  $store->save_lookup(
422                                  $normalize_path = $new_norm_path;                                          database => $database,
423                          } else {                                          input => $input_name,
424                                  $log->debug("--force-set failed on $new_norm_path, fallback to $normalize_path");                                          key => $key,
425                                            data => $lookup_data->{$database}->{$input_name}->{$key},
426                                    );
427                          }                          }
428                  }                  }
429    
430                  if ($normalize_path =~ m/\.xml$/i) {                  my $report_fh;
431                          $n->open(                  if ($stats || $validate) {
432                                  tag => $input->{normalize}->{tag},                          my $path = "out/report/${database}-${input_name}.txt";
433                                  xml_file => $normalize_path,                          open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
434                          );  
435                  } elsif ($normalize_path =~ m/\.(?:yml|yaml)$/i) {                          print $report_fh "Report for database '$database' input '$input_name' records ",
436                          $n->open_yaml(                                  $offset || 1, "-", $limit || $input->{limit} || $maxmfn, "\n\n";
437                                  path => $normalize_path,                          $log->info("Generating report file $path");
438                                  tag => $input->{normalize}->{tag},                  }
439    
440                    my $marc;
441                    if ($marc_generate && $parser->have_rules( 'marc', $database, $input_name )) {
442                            $marc = new WebPAC::Output::MARC(
443                                    path => "out/marc/${database}-${input_name}.marc",
444                                    lint => $marc_lint,
445                                    dump => $marc_dump,
446                          );                          );
                 } elsif ($normalize_path =~ m/\.(?:pl)$/i) {  
                         $n = undef;  
                         $log->info("using WebPAC::Normalize::Set to process $normalize_path");  
                         $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";  
447                  }                  }
448    
449                    my $rules = $parser->normalize_rules($database,$input_name) || $log->logdie("no normalize rules found for $database/$input_name");
450                    $log->debug("parsed normalize rules:\n$rules");
451    
452                    # reset position in database
453                    $input_db->seek(1);
454    
455                    # generate name of config key for indexer (strip everything after -)
456                    my $indexer_config = $use_indexer;
457                    $indexer_config =~ s/^(\w+)-?.*$/$1/g if ($indexer_config);
458    
459                    my $lookup_hash;
460                    my $depends = $parser->depends($database,$input_name);
461            
462                    if ($depends) {
463                            $log->debug("$database/$input_name depends on: ", dump($depends)) if ($depends);
464                            $log->logdie("parser->depends didn't return HASH") unless (ref($depends) eq 'HASH');
465    
466                            foreach my $db (keys %$depends) {
467                                    foreach my $i (keys %{$depends->{$db}}) {
468                                            foreach my $k (keys %{$depends->{$db}->{$i}}) {
469                                                    my $t = time();
470                                                    $log->debug("loading lookup $db/$i");
471                                                    $lookup_hash->{$db}->{$i}->{$k} = $store->load_lookup(
472                                                            database => $db,
473                                                            input => $i,
474                                                            key => $k,
475                                                    );
476                                                    $log->debug(sprintf("lookup $db/$i took %.2fs", time() - $t));
477                                            }
478                                    }
479                            }
480    
481                            $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
482                    }
483    
484    
485                  foreach my $pos ( 0 ... $input_db->size ) {                  foreach my $pos ( 0 ... $input_db->size ) {
486    
487                          my $row = $input_db->fetch || next;                          my $row = $input_db->fetch || next;
488    
489                            $total_rows++;
490    
491                          my $mfn = $row->{'000'}->[0];                          my $mfn = $row->{'000'}->[0];
492    
493                          if (! $mfn || $mfn !~ m#^\d+$#) {                          if (! $mfn || $mfn !~ m#^\d+$#) {
# Line 256  while (my ($database, $db_config) = each Line 496  while (my ($database, $db_config) = each
496                                  push @{ $row->{'000'} }, $pos;                                  push @{ $row->{'000'} }, $pos;
497                          }                          }
498    
                                   
                         my $ds;  
                         if ($n) {  
                                 $ds = $n->data_structure($row);  
                         } else {  
                                 $ds = WebPAC::Normalize::Set::data_structure(  
                                         row => $row,  
                                         rules => $rules,  
                                         lookup => $lookup->lookup_hash,  
                                 );  
499    
500                                  $db->save_ds(                          if ($validate) {
501                                          id => $mfn,                                  if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
502                                          ds => $ds,                                          $log->error( "MFN $mfn validation error:\n",
503                                          prefix => $input->{name},                                                  $validate->report_error( $errors )
504                                  ) if ($ds && !$stats);                                          );
505                                    }
506                                    next;   # validation doesn't create any output
507                          }                          }
508    
509                            my $ds = WebPAC::Normalize::data_structure(
510                                    row => $row,
511                                    rules => $rules,
512                                    lookup => $lookup_hash,
513                                    config => create_ds_config( $db_config, $database, $input, $mfn ),
514                                    marc_encoding => 'utf-8',
515                                    load_row_coderef => sub {
516                                            my ($database,$input,$mfn) = @_;
517                                            return $store->load_row(
518                                                    database => $database,
519                                                    input => $input,
520                                                    id => $mfn,
521                                            );
522                                    },
523                            );
524    
525                            $log->debug("ds = ", sub { dump($ds) }) if ($ds);
526    
527                            $store->save_ds(
528                                    database => $database,
529                                    input => $input_name,
530                                    id => $mfn,
531                                    ds => $ds,
532                            ) if ($ds && !$stats);
533    
534                          $indexer->add(                          $indexer->add(
535                                  id => $input->{name} . "/" . $mfn,                                  id => "${input_name}/${mfn}",
536                                  ds => $ds,                                  ds => $ds,
537                                  type => $config->{$use_indexer}->{type},                                  type => $config->get($indexer_config)->{type},
538                          ) if ($indexer);                          ) if ($indexer && $ds);
539    
540                          $total_rows++;                          if ($marc) {
541                                    my $i = 0;
542    
543                                    while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {
544                                            $marc->add(
545                                                    id => $mfn . ( $i ? "/$i" : '' ),
546                                                    fields => $fields,
547                                                    leader => WebPAC::Normalize::_get_marc_leader(),
548                                                    row => $row,
549                                            );
550                                            $i++;
551                                    }
552    
553                                    $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
554                            }
555                    }
556    
557                    if ($validate) {
558                            my $errors = $validate->report;
559                            if ($errors) {
560                                    $log->info("validation errors:\n$errors\n" );
561                                    print $report_fh "$errors\n" if ($report_fh);
562                            }
563                    }
564    
565                    if ($stats) {
566                            my $s = $input_db->stats;
567                            $log->info("statistics of fields usage:\n$s");
568                            print $report_fh "Statistics of fields usage:\n$s" if ($report_fh);
569                  }                  }
570    
571                  $log->info("statistics of fields usage:\n", $input_db->stats) if ($stats);                  # close MARC file
572                    $marc->finish if ($marc);
573    
574                    # close report
575                    close($report_fh) if ($report_fh)
576    
577          };          }
578    
579          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));
580    
581          my $dt = time() - $start_t;          my $dt = time() - $start_t;
582          $log->info("$total_rows records indexed in " .          $log->info("$total_rows records ", $indexer ? "indexed " : "",
583                  sprintf("%.2f sec [%.2f rec/sec]",                  sprintf("in %.2f sec [%.2f rec/sec]",
584                          $dt, ($total_rows / $dt)                          $dt, ($total_rows / $dt)
585                  )                  )
586          );          );
587    
588          #  
589          # add Hyper Estraier links to other databases          # end forked process
590          #          if ($parallel) {
591          if (ref($db_config->{links}) eq 'ARRAY') {                  $log->info("parallel process $$ finished");
592                  foreach my $link (@{ $db_config->{links} }) {                  exit(0);
                         if ($use_indexer eq 'hyperestraier') {  
                                 $log->info("adding link $database -> $link->{to} [$link->{credit}]");  
                                 $indexer->add_link(  
                                         from => $database,  
                                         to => $link->{to},  
                                         credit => $link->{credit},  
                                 );  
                         } else {  
                                 $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");  
                         }  
                 }  
593          }          }
594    
595  }  }
596    
597    if ($parallel) {
598            # wait all children to finish
599            sleep(1) while wait != -1;
600            $log->info("all parallel processes finished");
601    }
602    
603    #
604    # handle links or merge after indexing
605    #
606    
607    if ($merge) {
608            print $estcmd_fh 'sudo /etc/init.d/hyperestraier start',$/;
609            close($estcmd_fh);
610            chmod 0700, $estcmd_path || $log->warn("can't chmod 0700 $estcmd_path: $!");
611            system $estcmd_path;
612    } else {
613            foreach my $link (@links) {
614                    $log->logdie("coderef in link ", Dumper($link), " is ", ref($link), " and not CODE") unless (ref($link) eq 'CODE');
615                    $link->();
616            }
617    }
Legend:
Removed from v.509  
changed lines
  Added in v.814
  ViewVC Help
Powered by ViewVC 1.1.26