/[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 606 by dpavlin, Tue Aug 1 13:59:47 2006 UTC revision 1100 by dpavlin, Sat Aug 2 23:46:41 2008 UTC
# Line 7  use File::Temp qw/tempdir/; Line 7  use File::Temp qw/tempdir/;
7  use lib './lib';  use lib './lib';
8    
9  use WebPAC::Common 0.02;  use WebPAC::Common 0.02;
10  use WebPAC::Lookup 0.03;  use WebPAC::Parser 0.08;
11  use WebPAC::Input 0.07;  use WebPAC::Input 0.16;
12  use WebPAC::Store 0.03;  use WebPAC::Store 0.15;
13  use WebPAC::Normalize 0.11;  use WebPAC::Normalize 0.22;
14  use WebPAC::Output::TT;  use WebPAC::Output::TT;
15  use WebPAC::Validate;  use WebPAC::Validate 0.11;
16  use WebPAC::Output::MARC;  use WebPAC::Output::MARC;
17  use YAML qw/LoadFile/;  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/;  use Data::Dump qw/dump/;
23  use Storable qw/dclone/;  use Storable qw/dclone/;
24    use Pod::Usage qw/pod2usage/;
25    
 use Proc::Queue size => 1;  
26  use POSIX ":sys_wait_h"; # imports WNOHANG  use POSIX ":sys_wait_h"; # imports WNOHANG
27    
28  =head1 NAME  =head1 NAME
# Line 31  run.pl - start WebPAC indexing Line 31  run.pl - start WebPAC indexing
31    
32  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!>
33    
34  Options:  =head1 OPTIONS
35    
36  =over 4  =over 4
37    
# Line 60  path to YAML configuration file Line 60  path to YAML configuration file
60    
61  =item --stats  =item --stats
62    
63  disable indexing and dump statistics about field and subfield  disable indexing, modify_* in configuration and dump statistics about field
64  usage for each input  and subfield usage for each input
65    
66  =item --validate path/to/validation_file  =item --validate path/to/validation_file
67    
68  turn on extra validation of imput records, see L<WebPAC::Validation>  turn on extra validation of imput records, see L<WebPAC::Validation>
69    
70  =item --marc-normalize conf/normalize/mapping.pl  You can use special variables C<$database> and $C<$input> in this parametar
71    like C<--validate 'conf/validate/$database-$input'> to construct filename
72    
73  This option specifies normalisation file for MARC creation  =item --validate-delimiters path/to/validate_delimiters_file
74    
75  =item --marc-output out/marc/test.marc  this option is used with C<--validate> to turn on extra validation of
76    delimiters. If file is non existant, it will be created on first run.
77    
78  Optional path to output file  =item --marc-generate
79    
80    Generate MARC file. This will automatically be on if file contains C<marc*> directives.
81    You can use this option as C<--no-marc-generate> to disable MARC generation.
82    
83  =item --marc-lint  =item --marc-lint
84    
85  By default turned on if C<--marc-normalize> is used. You can disable lint  By default turned on if normalisation file has C<marc*> directives. You can disable lint
86  messages with C<--no-marc-lint>.  messages with C<--no-marc-lint>.
87    
88  =item --marc-dump  =item --marc-dump
# Line 89  Force dump or input and marc record for Line 94  Force dump or input and marc record for
94  Run databases in parallel (aproximatly same as number of processors in  Run databases in parallel (aproximatly same as number of processors in
95  machine if you want to use full load)  machine if you want to use full load)
96    
97    =item --only-links
98    
99    Create just links
100    
101    =item --merge
102    
103    Create merged index of databases which have links
104    
105  =back  =back
106    
107  =cut  =cut
# Line 97  my $offset; Line 110  my $offset;
110  my $limit;  my $limit;
111    
112  my $clean = 0;  my $clean = 0;
113  my $config = 'conf/config.yml';  my $config_path;
114  my $debug = 0;  my $debug = 0;
115  my $only_filter;  my $only_filter;
116  my $stats = 0;  my $stats = 0;
117  my $validate_path;  my $validate_path;
118  my ($marc_normalize, $marc_output);  my $validate_delimiters_path;
119    my $marc_generate = 1;
120  my $marc_lint = 1;  my $marc_lint = 1;
121  my $marc_dump = 0;  my $marc_dump = 0;
   
122  my $parallel = 0;  my $parallel = 0;
123    my $only_links = 0;
124    my $merge = 0;
125    my $help;
126    
127    my $log = _new WebPAC::Common()->_get_logger();
128    
129  GetOptions(  GetOptions(
130          "limit=i" => \$limit,          "limit=i" => \$limit,
# Line 114  GetOptions( Line 132  GetOptions(
132          "clean" => \$clean,          "clean" => \$clean,
133          "one=s" => \$only_filter,          "one=s" => \$only_filter,
134          "only=s" => \$only_filter,          "only=s" => \$only_filter,
135          "config" => \$config,          "config=s" => \$config_path,
136          "debug+" => \$debug,          "debug+" => \$debug,
137          "stats" => \$stats,          "stats" => \$stats,
138          "validate=s" => \$validate_path,          "validate=s" => \$validate_path,
139          "marc-normalize=s" => \$marc_normalize,          "validate-delimiters=s" => \$validate_delimiters_path,
140          "marc-output=s" => \$marc_output,          "marc-generate!" => \$marc_generate,
141          "marc-lint!" => \$marc_lint,          "marc-lint!" => \$marc_lint,
142          "marc-dump!" => \$marc_dump,          "marc-dump!" => \$marc_dump,
143          "parallel=i" => \$parallel,          "parallel=i" => \$parallel,
144            "only-links!" => \$only_links,
145            "merge" => \$merge,
146            "help" => \$help,
147  );  );
148    
149  $config = LoadFile($config);  $marc_generate = 0 if ( $validate_delimiters_path );
150    
151  print "config = ",dump($config) if ($debug);  pod2usage(-verbose => 2) if ($help);
152    
153  die "no databases in config file!\n" unless ($config->{databases});  my $config = new WebPAC::Config( path => $config_path );
154    
155    WebPAC::Normalize::_debug( $debug - 1 ) if $debug > 1;
156    
157    #print "config = ",dump($config) if ($debug);
158    
159    die "no databases in config file!\n" unless ($config->databases);
160    
 my $log = _new WebPAC::Common()->_get_logger();  
161  $log->info( "-" x 79 );  $log->info( "-" x 79 );
162    
163    my $log_file = 'log';
164    
165    if (-e $log_file ) {    # && -s $log_file > 5 * 1024 * 1024) {
166            $log->info("moved old log with ", -s $log_file, " bytes to '${log_file}.old'");
167            rename $log_file, "${log_file}.old" || $log->logwarn("can't rename $log_file to ${log_file}.old: $!");
168    }
169    
170    my $estcmd_fh;
171    my $estcmd_path = './estcmd-merge.sh';
172    if ($merge) {
173            open($estcmd_fh, '>', $estcmd_path) || $log->logdie("can't open $estcmd_path: $!");
174            print $estcmd_fh 'cd /data/estraier/_node/ || exit 1',$/;
175            print $estcmd_fh 'sudo /etc/init.d/hyperestraier stop',$/;
176            $log->info("created merge batch file $estcmd_path");
177    }
178    
179  my $validate;  my $validate;
180  $validate = new WebPAC::Validate(  $validate = new WebPAC::Validate(
181          path => $validate_path,          delimiters => $config->webpac('delimiters'),
182  ) if ($validate_path);  ) if ($validate_path || $validate_delimiters_path);
183    
184  my $use_indexer = $config->{use_indexer} || 'hyperestraier';  my $use_indexer = $config->use_indexer;
185    $stats ||= $validate;
186  if ($stats) {  if ($stats) {
187          $log->debug("option --stats disables update of indexing engine...");          $log->debug("disabled indexing for stats collection");
188          $use_indexer = undef;          $use_indexer = undef;
189  } else {  } elsif ( $use_indexer ) {
190          $log->info("using $use_indexer indexing engine...");          $log->info("using $use_indexer indexing engine...");
191  }  }
192    
193  # disable indexing when creating marc  # parse normalize files and create source files for lookup and normalization
194  $use_indexer = undef if ($marc_normalize);  
195    my ($only_database,$only_input) = split(m#/#, $only_filter) if $only_filter;
196    
197    my $parser = new WebPAC::Parser(
198            config => $config,
199            only_database => $only_database,
200            only_input => $only_input,
201    );
202    
203  my $total_rows = 0;  my $total_rows = 0;
204  my $start_t = time();  my $start_t = time();
205    
206  my @links;  my @links;
 my $indexer;  
207    
208  if ($parallel) {  if ($parallel) {
209            eval 'use Proc::Queue size => 1;';
210            die $@ if $@;
211          $log->info("Using $parallel processes for speedup");          $log->info("Using $parallel processes for speedup");
212          Proc::Queue::size($parallel);          Proc::Queue::size($parallel);
213  }  }
214    
215  while (my ($database, $db_config) = each %{ $config->{databases} }) {  sub create_ds_config {
216            my ($db_config, $database, $input, $mfn) = @_;
217            my $c = dclone( $db_config );
218            $c->{_} = $database || $log->logconfess("need database");
219            $c->{_mfn} = $mfn || $log->logconfess("need mfn");
220            $c->{input} = $input || $log->logconfess("need input");
221            return $c;
222    }
223    
224    foreach my $database ( sort keys %{ $config->databases } ) {
225            my $db_config = $config->databases->{$database};
226    
         my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);  
227          next if ($only_database && $database !~ m/$only_database/i);          next if ($only_database && $database !~ m/$only_database/i);
228    
229          if ($parallel) {          if ($parallel) {
# Line 175  while (my ($database, $db_config) = each Line 235  while (my ($database, $db_config) = each
235                  }                  }
236          }          }
237    
238          if ($use_indexer) {          my $indexer;
239                  my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");          if ($use_indexer && $parser->have_rules( 'search', $database )) {
240    
241                    my $cfg_name = $use_indexer;
242                    $cfg_name =~ s/\-.*$//;
243    
244                    my $indexer_config = $config->get( $cfg_name ) || $log->logdie("can't find '$cfg_name' part in confguration");
245                  $indexer_config->{database} = $database;                  $indexer_config->{database} = $database;
246                  $indexer_config->{clean} = $clean;                  $indexer_config->{clean} = $clean;
247                  $indexer_config->{label} = $db_config->{name};                  $indexer_config->{label} = $db_config->{name};
248    
249                    # force clean if database has links
250                    $indexer_config->{clean} = 1 if ($db_config->{links});
251    
252                  if ($use_indexer eq 'hyperestraier') {                  if ($use_indexer eq 'hyperestraier') {
253    
254                          # open Hyper Estraier database                          # open Hyper Estraier database
255                          use WebPAC::Output::Estraier '0.10';                          require WebPAC::Output::Estraier;
256                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
257                                    
258                    } elsif ($use_indexer eq 'hyperestraier-native') {
259    
260                            # open Hyper Estraier database
261                            require WebPAC::Output::EstraierNative;
262                            $indexer = new WebPAC::Output::EstraierNative( %{ $indexer_config } );
263    
264                  } elsif ($use_indexer eq 'kinosearch') {                  } elsif ($use_indexer eq 'kinosearch') {
265    
266                          # open KinoSearch                          die "no longer supported";
                         use WebPAC::Output::KinoSearch;  
                         $indexer_config->{clean} = 1 unless (-e $indexer_config->{index_path});  
                         $indexer = new WebPAC::Output::KinoSearch( %{ $indexer_config } );  
267    
268                  } else {                  } else {
269                          $log->logdie("unknown use_indexer: $use_indexer");                          $log->logdie("unknown use_indexer: $use_indexer");
270                  }                  }
271    
272                  $log->logide("can't continue without valid indexer") unless ($indexer);                  $log->logdie("can't continue without valid indexer") unless ($indexer);
273            }
274    
275    
276            #
277            # store Hyper Estraier links to other databases
278            #
279            if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {
280                    foreach my $link (@{ $db_config->{links} }) {
281                            if ($use_indexer eq 'hyperestraier') {
282                                    if ($merge) {
283                                            print $estcmd_fh 'sudo -u www-data estcmd merge ' . $database . ' ' . $link->{to},$/;
284                                    } else {
285                                            $log->info("saving link $database -> $link->{to} [$link->{credit}]");
286                                            push @links, sub {
287                                                    $log->info("adding link $database -> $link->{to} [$link->{credit}]");
288                                                    $indexer->add_link(
289                                                            from => $database,
290                                                            to => $link->{to},
291                                                            credit => $link->{credit},
292                                                    );
293                                            };
294                                    }
295                            } else {
296                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
297                            }
298                    }
299          }          }
300            next if ($only_links);
301    
302    
303          #          #
304          # now WebPAC::Store          # now WebPAC::Store
305          #          #
306          my $abs_path = abs_path($0);          my $store = new WebPAC::Store({
307          $abs_path =~ s#/[^/]*$#/#;                  debug => $debug,
308            });
309    
         my $db_path = $config->{webpac}->{db_path} . '/' . $database;  
310    
311          if ($clean) {          #
312                  $log->info("creating new database '$database' in $db_path");          # prepare output
313                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");          #
314          } else {          my @outputs = force_array( $db_config->{output}, sub {
315                  $log->info("working on database '$database' in $db_path");                  $log->error("Database $database doesn't have any outputs defined. Do you want to remove it from configuration?" );
316            } );
317    
318            my @output_modules;
319    
320            foreach my $output ( @outputs ) {
321    
322    #warn '## output = ',dump( $output );
323    
324                    my $module = $output->{module} || $log->logdie("need module in output section of $database");
325                    $module = 'WebPAC::Output::' . $module unless $module =~ m/::/;
326            
327                    $log->debug("loading output module $module");
328                    eval "require $module";
329    
330                    # add database to arugemnts for output filter
331                    $output->{database} = $database;
332                    $output->{clean} = $clean;
333    
334                    $log->debug("calling $module->new(",dump( $output ),")");
335                    my $out = new $module->new( $output );
336                    if ( $out->init ) {
337                            push @output_modules, $out;
338                    } else {
339                            $log->warn("SKIPPED $module");
340                    }
341          }          }
342    
         my $db = new WebPAC::Store(  
                 path => $db_path,  
                 database => $database,  
                 debug => $debug,  
         );  
   
343    
344          #          #
345          # now, iterate through input formats          # now, iterate through input formats
346          #          #
347    
348          my @inputs;  
349          if (ref($db_config->{input}) eq 'ARRAY') {          my @inputs = force_array( $db_config->{input}, sub {
                 @inputs = @{ $db_config->{input} };  
         } elsif ($db_config->{input}) {  
                 push @inputs, $db_config->{input};  
         } else {  
350                  $log->info("database $database doesn't have inputs defined");                  $log->info("database $database doesn't have inputs defined");
351          }          } );
352    
353          my @supported_inputs = keys %{ $config->{webpac}->{inputs} };          if ( -e 'out/debug' ) { # FIXME flag?
354                    my $out;
355                    foreach my $i ( @inputs ) {
356                            warn dump( $i );
357                            next unless defined $i->{normalize};
358                            warn dump( $i->{normalize} );
359                            foreach my $normalize ( @{ $i->{normalize} } ) {
360                                    my $path = $normalize->{path};
361                                    $out .= qq/\n##\n## $path\n##\n\n/;
362                                    $out .= read_file( $path );
363                            }
364                    }
365                    my $all = "out/debug/all-normalize.pl";
366                    write_file( $all, $out );
367                    warn "### all normalize for this input saved to: $all";
368            };
369    
370          foreach my $input (@inputs) {          foreach my $input (@inputs) {
371    
372                  next if ($only_input && ($input->{name} !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));                  my $input_name = $input->{name} || $log->logdie("input without a name isn't valid: ",dump($input));
373    
374                    next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
375    
376                  my $type = lc($input->{type});                  my $type = lc($input->{type});
377    
378                  die "I know only how to handle input types ", join(",", @supported_inputs), " not '$type'!\n" unless (grep(/$type/, @supported_inputs));                  # FIXME check if input module exists
379                    my $input_module = $input->{module};
380    
381                  my $lookup;                  if ( ! $input_module ) {
382                  if ($input->{lookup}) {                          if ( grep(/$type/, $config->webpac('inputs')) ) {
383                          $lookup = new WebPAC::Lookup(                                  $input_module = $config->webpac('inputs')->{$type};
384                                  lookup_file => $input->{lookup},                          } else {
385                          );                                  $log->logdie("I know only how to handle input types ", join(",", $config->webpac('inputs') ), " not '$type'!" );
386                          delete( $input->{lookup} );                          }
387                  }                  }
388    
389                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my @lookups = $parser->have_lookup_create($database, $input);
390    
391                  $log->info("working on input '$input->{name}' in $input->{path} [type: $input->{type}] using $input_module",                  $log->info("working on $database/$input_name with $input_module on $input->{path}",
392                          $input->{lookup} ? "lookup '$input->{lookup}'" : ""                          @lookups ? " creating lookups: ".join(", ", @lookups) : ""
393                  );                  );
394    
395                    if ($stats) {
396                            # disable modification of records if --stats is in use
397                            delete($input->{modify_records});
398                            delete($input->{modify_file});
399                    }
400    
401                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
402                          module => $input_module,                          module => $input_module,
                         encoding => $config->{webpac}->{webpac_encoding},  
403                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
404                          offset => $offset,                          offset => $offset,
                         lookup_coderef => sub {  
                                 my $rec = shift || return;  
                                 $lookup->add( $rec );  
                         },  
405                          recode => $input->{recode},                          recode => $input->{recode},
406                          stats => $stats,                          stats => $stats,
407                          modify_records => $input->{modify_records},                          modify_records => $input->{modify_records},
408                            modify_file => $input->{modify_file},
409                            input_config => $input,
410                  );                  );
411                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
412    
413                    if (defined( $input->{lookup} )) {
414                            $log->warn("$database/$input_name has depriciated lookup definition, removing it...");
415                            delete( $input->{lookup} );
416                    }
417    
418                    my $lookup_coderef;
419    
420                    if (@lookups) {
421    
422                            my $rules = $parser->lookup_create_rules($database, $input) || $log->logdie("no rules found for $database/$input");
423    
424                            $lookup_coderef = sub {
425                                    my $rec = shift || die "need rec!";
426                                    my $mfn = $rec->{'000'}->[0] || die "need mfn in 000";
427    
428                                    WebPAC::Normalize::data_structure(
429                                            row => $rec,
430                                            rules => $rules,
431                                            config => create_ds_config( $db_config, $database, $input, $mfn ),
432                                    );
433    
434                                    #warn "current lookup: ", dump(WebPAC::Normalize::_get_lookup());
435                            };
436    
437                            WebPAC::Normalize::_set_lookup( undef );
438    
439                            $log->debug("created lookup_coderef using:\n$rules");
440    
441                    };
442    
443                    my $lookup_jar;
444    
445                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
446                          path => $input->{path},                          path => $input->{path},
447                          code_page => $input->{encoding},        # database encoding                          input_encoding => $input->{encoding},   # database encoding
448                            lookup_coderef => $lookup_coderef,
449                            lookup => $lookup_jar,
450                          %{ $input },                          %{ $input },
451                            load_row => sub {
452                                    my $a = shift;
453                                    return $store->load_row(
454                                            database => $database,
455                                            input => $input_name,
456                                            id => $a->{id},
457                                    );
458                            },
459                            save_row => sub {
460                                    my $a = shift;
461                                    return $store->save_row(
462                                            database => $database,
463                                            input => $input_name,
464                                            id => $a->{id},
465                                            row => $a->{row},
466                                    );
467                            },
468    
469                  );                  );
470    
471                  my @norm_array = ref($input->{normalize}) eq 'ARRAY' ?                  my $lookup_data = WebPAC::Normalize::_get_lookup();
472                          @{ $input->{normalize} } : ( $input->{normalize} );  
473                    if (defined( $lookup_data->{$database}->{$input_name} )) {
474                            $log->debug("created following lookups: ", sub { dump( $lookup_data ) } );
475    
476                  if ($marc_normalize) {                          foreach my $key (keys %{ $lookup_data->{$database}->{$input_name} }) {
477                          @norm_array = ( {                                  $store->save_lookup(
478                                  path => $marc_normalize,                                          database => $database,
479                                  output => $marc_output || 'out/marc/' . $database . '-' . $input->{name} . '.marc',                                          input => $input_name,
480                          } );                                          key => $key,
481                                            data => $lookup_data->{$database}->{$input_name}->{$key},
482                                    );
483                            }
484                  }                  }
485    
486                  foreach my $normalize (@norm_array) {                  my $report_fh;
487                    if ($stats || $validate) {
488                            my $path = "out/report/${database}-${input_name}.txt";
489                            open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
490    
491                            print $report_fh "Report for database '$database' input '$input_name' records ",
492                                    $offset || 1, "-", $limit || $input->{limit} || $maxmfn, "\n\n";
493                            $log->info("Generating report file $path");
494    
495                            if ( $validate ) {
496                                    $validate->read_validate_file( $validate->fill_in( $validate_path, database => $database, input => $input_name ) ) if ( $validate_path );
497                                    $validate->read_validate_delimiters_file( $validate->fill_in( $validate_delimiters_path, database => $database, input => $input_name ) ) if ( $validate_delimiters_path );
498                            }
499                    }
500    
501                          my $normalize_path = $normalize->{path} || $log->logdie("can't find normalize path in config");                  my $marc;
502                    if ($marc_generate && $parser->have_rules( 'marc', $database, $input_name )) {
503                            $marc = new WebPAC::Output::MARC(
504                                    path => "out/marc/${database}-${input_name}.marc",
505                                    lint => $marc_lint,
506                                    dump => $marc_dump,
507                            );
508                    }
509    
510                          $log->logdie("Found '$normalize_path' as normalization file which isn't supported any more!") unless ( $normalize_path =~ m!\.pl$!i );                  my $rules = $parser->normalize_rules($database,$input_name);
511                    $log->logwarn("no normalize rules for $database/$input_name") unless $rules;
512    
513                          my $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";                  $log->debug("parsed normalize rules:\n$rules");
514    
515                          $log->info("Using $normalize_path for normalization...");                  # reset position in database
516                    $input_db->seek(1);
517    
518                          my $marc = new WebPAC::Output::MARC(                  # generate name of config key for indexer (strip everything after -)
519                                  path => $normalize->{output},                  my $indexer_config = $use_indexer;
520                                  lint => $marc_lint,                  $indexer_config =~ s/^(\w+)-?.*$/$1/g if ($indexer_config);
521                                  dump => $marc_dump,  
522                          ) if ($normalize->{output});                  my $lookup_hash;
523                    my $depends = $parser->depends($database,$input_name);
524            
525                    if ($depends) {
526                            $log->debug("$database/$input_name depends on: ", dump($depends)) if ($depends);
527                            $log->logdie("parser->depends didn't return HASH") unless (ref($depends) eq 'HASH');
528    
529                            foreach my $db (keys %$depends) {
530                                    foreach my $i (keys %{$depends->{$db}}) {
531                                            foreach my $k (keys %{$depends->{$db}->{$i}}) {
532                                                    my $t = time();
533                                                    $log->debug("loading lookup $db/$i");
534                                                    $lookup_hash->{$db}->{$i}->{$k} = $store->load_lookup(
535                                                            database => $db,
536                                                            input => $i,
537                                                            key => $k,
538                                                    );
539                                                    $log->debug(sprintf("lookup $db/$i took %.2fs", time() - $t));
540                                            }
541                                    }
542                            }
543    
544                          # reset position in database                          $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
545                          $input_db->seek(1);                  }
546    
                         foreach my $pos ( 0 ... $input_db->size ) {  
547    
548                                  my $row = $input_db->fetch || next;                  # setup input name for all output filters
549                    foreach my $out ( @output_modules ) {
550                            if ( $out->can('input') ) {
551                                    $out->input( $input_name );
552                            } else {
553                                    $log->warn("output filter ",ref($out)," doesn't support input name");
554                            }
555                    }
556    
                                 my $mfn = $row->{'000'}->[0];  
557    
558                                  if (! $mfn || $mfn !~ m#^\d+$#) {                  foreach my $pos ( 0 ... $input_db->size ) {
                                         $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");  
                                         $mfn = $pos;  
                                         push @{ $row->{'000'} }, $pos;  
                                 }  
559    
560                            my $row = $input_db->fetch || next;
561    
562                                  if ($validate) {                          $total_rows++;
                                         my @errors = $validate->validate_errors( $row );  
                                         $log->error( "MFN $mfn validation errors:\n", join("\n", @errors) ) if (@errors);  
                                 }  
563    
564                                  my $ds_config = dclone($db_config);                          my $mfn = $row->{'000'}->[0];
565    
566                                  # default values -> database key                          if (! $mfn || $mfn !~ m{^\d+$}) {
567                                  $ds_config->{_} = $database;                                  $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");
568                                    $mfn = $pos;
569                                    push @{ $row->{'000'} }, $pos;
570                            }
571    
                                 # current mfn  
                                 $ds_config->{_mfn} = $mfn;  
572    
573                                  # attach current input                          if ($validate) {
574                                  $ds_config->{input} = $input;                                  if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
575                                            $log->error( "MFN $mfn validation error:\n",
576                                                    $validate->report_error( $errors )
577                                            );
578                                    }
579                                    next;   # validation doesn't create any output
580                            }
581    
582                            if ($rules) {
583    
584                                  my $ds = WebPAC::Normalize::data_structure(                                  my $ds = WebPAC::Normalize::data_structure(
585                                          row => $row,                                          row => $row,
586                                          rules => $rules,                                          rules => $rules,
587                                          lookup => $lookup ? $lookup->lookup_hash : undef,                                          lookup => $lookup_hash,
588                                          config => $ds_config,                                          config => create_ds_config( $db_config, $database, $input, $mfn ),
589                                          marc_encoding => 'utf-8',                                          marc_encoding => 'utf-8',
590                                            load_row_coderef => sub {
591                                                    my ($database,$input,$mfn) = @_;
592    #warn "### load_row($database,$input,$mfn) from data_structure\n";
593                                                    return $store->load_row(
594                                                            database => $database,
595                                                            input => $input,
596                                                            id => $mfn,
597                                                    );
598                                            },
599                                  );                                  );
600    
601                                  $db->save_ds(                                  $log->debug("ds = ", sub { dump($ds) });
602                                          id => $mfn,  
603                                          ds => $ds,                                  if ( $ds ) {
604                                          prefix => $input->{name},  
605                                  ) if ($ds && !$stats);                                          $store->save_ds(
606                                                    database => $database,
607                                  $indexer->add(                                                  input => $input_name,
608                                          id => $input->{name} . "/" . $mfn,                                                  id => $mfn,
609                                          ds => $ds,                                                  ds => $ds,
610                                          type => $config->{$use_indexer}->{type},                                          ) if !$stats;
611                                  ) if ($indexer && $ds);  
612                                            $indexer->add(
613                                  if ($marc) {                                                  id => "${input_name}/${mfn}",
614                                          my $i = 0;                                                  ds => $ds,
615                                                    type => $config->get($indexer_config)->{type},
616                                          while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {                                          ) if $indexer;
617                                                  $marc->add(  
618                                                          id => $mfn . ( $i ? "/$i" : '' ),                                          foreach my $out ( @output_modules ) {
619                                                          fields => $fields,                                                  $out->add( $mfn, $ds ) if $out->can('add');
                                                         leader => WebPAC::Normalize::marc_leader(),  
                                                         row => $row,  
                                                 );  
                                                 $i++;  
620                                          }                                          }
621    
622                                          $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);                                  } else {
623                                            $log->warn("record $pos didn't produce any output after normalization rules!") unless $marc;
624                                  }                                  }
625                            }
626    
627                                  $total_rows++;                          if ($marc) {
628                                    my $i = 0;
629    
630                                    while (my $fields = WebPAC::Normalize::MARC::_get_marc_fields( fetch_next => 1 ) ) {
631                                            $marc->add(
632                                                    id => $mfn . ( $i ? "/$i" : '' ),
633                                                    fields => $fields,
634                                                    leader => WebPAC::Normalize::MARC::_get_marc_leader(),
635                                                    row => $row,
636                                            );
637                                            $i++;
638                                    }
639    
640                                    $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
641                            }
642    
643                    }
644    
645                    if ($validate) {
646                            my $errors = $validate->report;
647                            if ($errors) {
648                                    $log->info("validation errors:\n$errors\n" );
649                                    print $report_fh "$errors\n" if ($report_fh);
650                          }                          }
651    
652                          $log->info("statistics of fields usage:\n", $input_db->stats) if ($stats);                          print $report_fh "\nAll possible subfields/delimiter templates:\n", $validate->delimiters_templates( report => 1, current_input => 1 ), "\n\n";
653    
654                          # close MARC file                          # must be last thing that touches $validate for this input
655                          $marc->finish if ($marc);                          $validate->reset;
656                    }
657    
658                    if ($stats) {
659                            my $s = $input_db->stats;
660                            $log->info("statistics of fields usage:\n$s");
661                            print $report_fh "Statistics of fields usage:\n$s" if ($report_fh);
662                  }                  }
663    
664                    # close MARC file
665                    $marc->finish if ($marc);
666    
667                    # close report
668                    close($report_fh) if ($report_fh);
669          }          }
670    
671          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));
672    
673            foreach my $out ( @output_modules ) {
674                    $out->finish if $out->can('finish');
675            }
676    
677          my $dt = time() - $start_t;          my $dt = time() - $start_t;
678          $log->info("$total_rows records ", $indexer ? "indexed " : "",          $log->info("$total_rows records ", $indexer ? "indexed " : "",
679                  sprintf("in %.2f sec [%.2f rec/sec]",                  sprintf("in %.2f sec [%.2f rec/sec]",
# Line 397  while (my ($database, $db_config) = each Line 681  while (my ($database, $db_config) = each
681                  )                  )
682          );          );
683    
         #  
         # add Hyper Estraier links to other databases  
         #  
         if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {  
                 foreach my $link (@{ $db_config->{links} }) {  
                         if ($use_indexer eq 'hyperestraier') {  
                                 $log->info("saving link $database -> $link->{to} [$link->{credit}]");  
                                 push @links, {  
                                         from => $database,  
                                         to => $link->{to},  
                                         credit => $link->{credit},  
                                 };  
                         } else {  
                                 $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");  
                         }  
                 }  
         }  
684    
685          # end forked process          # end forked process
686          if ($parallel) {          if ($parallel) {
# Line 429  if ($parallel) { Line 696  if ($parallel) {
696          $log->info("all parallel processes finished");          $log->info("all parallel processes finished");
697  }  }
698    
699  foreach my $link (@links) {  # save new delimiters if needed
700          $log->info("adding link $link->{from} -> $link->{to} [$link->{credit}]");  $validate->save_delimiters_templates if ( $validate_delimiters_path );
         $indexer->add_link( %{ $link } );  
 }  
701    
702    #
703    # handle links or merge after indexing
704    #
705    
706    if ($merge) {
707            print $estcmd_fh 'sudo /etc/init.d/hyperestraier start',$/;
708            close($estcmd_fh);
709            chmod 0700, $estcmd_path || $log->warn("can't chmod 0700 $estcmd_path: $!");
710            system $estcmd_path;
711    } else {
712            foreach my $link (@links) {
713                    $log->logdie("coderef in link ", Dumper($link), " is ", ref($link), " and not CODE") unless (ref($link) eq 'CODE');
714                    $link->();
715            }
716    }
Legend:
Removed from v.606  
changed lines
  Added in v.1100
  ViewVC Help
Powered by ViewVC 1.1.26