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