/[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 969 by dpavlin, Fri Nov 2 14:28:43 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    #print "config = ",dump($config) if ($debug);
157    
158    die "no databases in config file!\n" unless ($config->databases);
159    
 my $log = _new WebPAC::Common()->_get_logger();  
160  $log->info( "-" x 79 );  $log->info( "-" x 79 );
161    
162    my $log_file = 'log';
163    
164    if (-e $log_file ) {    # && -s $log_file > 5 * 1024 * 1024) {
165            $log->info("moved old log with ", -s $log_file, " bytes to '${log_file}.old'");
166            rename $log_file, "${log_file}.old" || $log->logwarn("can't rename $log_file to ${log_file}.old: $!");
167    }
168    
169    my $estcmd_fh;
170    my $estcmd_path = './estcmd-merge.sh';
171    if ($merge) {
172            open($estcmd_fh, '>', $estcmd_path) || $log->logdie("can't open $estcmd_path: $!");
173            print $estcmd_fh 'cd /data/estraier/_node/ || exit 1',$/;
174            print $estcmd_fh 'sudo /etc/init.d/hyperestraier stop',$/;
175            $log->info("created merge batch file $estcmd_path");
176    }
177    
178  my $validate;  my $validate;
179  $validate = new WebPAC::Validate(  $validate = new WebPAC::Validate(
180          path => $validate_path,          delimiters => $config->webpac('delimiters'),
181  ) if ($validate_path);  ) if ($validate_path || $validate_delimiters_path);
182    
183  my $use_indexer = $config->{use_indexer} || 'hyperestraier';  my $use_indexer = $config->use_indexer;
184    $stats ||= $validate;
185  if ($stats) {  if ($stats) {
186          $log->debug("option --stats disables update of indexing engine...");          $log->debug("disabled indexing for stats collection");
187          $use_indexer = undef;          $use_indexer = undef;
188  } else {  } elsif ( $use_indexer ) {
189          $log->info("using $use_indexer indexing engine...");          $log->info("using $use_indexer indexing engine...");
190  }  }
191    
192  # disable indexing when creating marc  # parse normalize files and create source files for lookup and normalization
193  $use_indexer = undef if ($marc_normalize);  
194    my $parser = new WebPAC::Parser( config => $config );
195    
196  my $total_rows = 0;  my $total_rows = 0;
197  my $start_t = time();  my $start_t = time();
198    
199  my @links;  my @links;
 my $indexer;  
200    
201  if ($parallel) {  if ($parallel) {
202          $log->info("Using $parallel processes for speedup");          $log->info("Using $parallel processes for speedup");
203          Proc::Queue::size($parallel);          Proc::Queue::size($parallel);
204  }  }
205    
206  while (my ($database, $db_config) = each %{ $config->{databases} }) {  sub create_ds_config {
207            my ($db_config, $database, $input, $mfn) = @_;
208            my $c = dclone( $db_config );
209            $c->{_} = $database || $log->logconfess("need database");
210            $c->{_mfn} = $mfn || $log->logconfess("need mfn");
211            $c->{input} = $input || $log->logconfess("need input");
212            return $c;
213    }
214    
215    foreach my $database ( sort keys %{ $config->databases } ) {
216            my $db_config = $config->databases->{$database};
217    
218          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);
219          next if ($only_database && $database !~ m/$only_database/i);          next if ($only_database && $database !~ m/$only_database/i);
# Line 175  while (my ($database, $db_config) = each Line 227  while (my ($database, $db_config) = each
227                  }                  }
228          }          }
229    
230          if ($use_indexer) {          my $indexer;
231                  my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");          if ($use_indexer && $parser->have_rules( 'search', $database )) {
232    
233                    my $cfg_name = $use_indexer;
234                    $cfg_name =~ s/\-.*$//;
235    
236                    my $indexer_config = $config->get( $cfg_name ) || $log->logdie("can't find '$cfg_name' part in confguration");
237                  $indexer_config->{database} = $database;                  $indexer_config->{database} = $database;
238                  $indexer_config->{clean} = $clean;                  $indexer_config->{clean} = $clean;
239                  $indexer_config->{label} = $db_config->{name};                  $indexer_config->{label} = $db_config->{name};
240    
241                    # force clean if database has links
242                    $indexer_config->{clean} = 1 if ($db_config->{links});
243    
244                  if ($use_indexer eq 'hyperestraier') {                  if ($use_indexer eq 'hyperestraier') {
245    
246                          # open Hyper Estraier database                          # open Hyper Estraier database
247                          use WebPAC::Output::Estraier '0.10';                          require WebPAC::Output::Estraier;
248                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
249                                    
250                    } elsif ($use_indexer eq 'hyperestraier-native') {
251    
252                            # open Hyper Estraier database
253                            require WebPAC::Output::EstraierNative;
254                            $indexer = new WebPAC::Output::EstraierNative( %{ $indexer_config } );
255    
256                  } elsif ($use_indexer eq 'kinosearch') {                  } elsif ($use_indexer eq 'kinosearch') {
257    
258                          # 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 } );  
259    
260                  } else {                  } else {
261                          $log->logdie("unknown use_indexer: $use_indexer");                          $log->logdie("unknown use_indexer: $use_indexer");
262                  }                  }
263    
264                  $log->logide("can't continue without valid indexer") unless ($indexer);                  $log->logdie("can't continue without valid indexer") unless ($indexer);
265          }          }
266    
267    
268          #          #
269            # store Hyper Estraier links to other databases
270            #
271            if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {
272                    foreach my $link (@{ $db_config->{links} }) {
273                            if ($use_indexer eq 'hyperestraier') {
274                                    if ($merge) {
275                                            print $estcmd_fh 'sudo -u www-data estcmd merge ' . $database . ' ' . $link->{to},$/;
276                                    } else {
277                                            $log->info("saving link $database -> $link->{to} [$link->{credit}]");
278                                            push @links, sub {
279                                                    $log->info("adding link $database -> $link->{to} [$link->{credit}]");
280                                                    $indexer->add_link(
281                                                            from => $database,
282                                                            to => $link->{to},
283                                                            credit => $link->{credit},
284                                                    );
285                                            };
286                                    }
287                            } else {
288                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
289                            }
290                    }
291            }
292            next if ($only_links);
293    
294    
295            #
296          # now WebPAC::Store          # now WebPAC::Store
297          #          #
298          my $abs_path = abs_path($0);          my $store = new WebPAC::Store({
299          $abs_path =~ s#/[^/]*$#/#;                  debug => $debug,
300            });
301    
         my $db_path = $config->{webpac}->{db_path} . '/' . $database;  
302    
303          if ($clean) {          #
304                  $log->info("creating new database '$database' in $db_path");          # prepare output
305                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");          #
306          } else {          my @outputs = force_array( $db_config->{output}, sub {
307                  $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?" );
308          }          } );
309    
310          my $db = new WebPAC::Store(          my @output_modules;
311                  path => $db_path,  
312                  database => $database,          foreach my $output ( @outputs ) {
313                  debug => $debug,  
314          );  #warn '## output = ',dump( $output );
315    
316                    my $module = $output->{module} || $log->logdie("need module in output section of $database");
317                    $module = 'WebPAC::Output::' . $module unless $module =~ m/::/;
318            
319                    $log->debug("loading output module $module");
320                    eval "require $module";
321    
322                    # add database to arugemnts for output filter
323                    $output->{database} = $database;
324    
325                    $log->debug("calling $module->new(",dump( $output ),")");
326                    my $out = new $module->new( $output );
327                    $out->init;
328    
329                    push @output_modules, $out;
330            }
331    
332    
333          #          #
334          # now, iterate through input formats          # now, iterate through input formats
335          #          #
336    
         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");  
         }  
337    
338          my @supported_inputs = keys %{ $config->{webpac}->{inputs} };          my @inputs = force_array( $db_config->{input}, sub {
339                    $log->info("database $database doesn't have inputs defined");
340            } );
341    
342          foreach my $input (@inputs) {          foreach my $input (@inputs) {
343    
344                  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));
345    
346                    next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
347    
348                  my $type = lc($input->{type});                  my $type = lc($input->{type});
349    
350                  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
351                    my $input_module = $input->{module};
352    
353                  my $lookup;                  if ( ! $input_module ) {
354                  if ($input->{lookup}) {                          if ( grep(/$type/, $config->webpac('inputs')) ) {
355                          $lookup = new WebPAC::Lookup(                                  $input_module = $config->webpac('inputs')->{$type};
356                                  lookup_file => $input->{lookup},                          } else {
357                          );                                  $log->logdie("I know only how to handle input types ", join(",", $config->webpac('inputs') ), " not '$type'!" );
358                          delete( $input->{lookup} );                          }
359                  }                  }
360    
361                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my @lookups = $parser->have_lookup_create($database, $input);
362    
363                  $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",
364                          $input->{lookup} ? "lookup '$input->{lookup}'" : ""                          @lookups ? " creating lookups: ".join(", ", @lookups) : ""
365                  );                  );
366    
367                    if ($stats) {
368                            # disable modification of records if --stats is in use
369                            delete($input->{modify_records});
370                            delete($input->{modify_file});
371                    }
372    
373                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
374                          module => $input_module,                          module => $input_module,
375                          encoding => $config->{webpac}->{webpac_encoding},                          encoding => $config->webpac('webpac_encoding'),
376                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
377                          offset => $offset,                          offset => $offset,
                         lookup_coderef => sub {  
                                 my $rec = shift || return;  
                                 $lookup->add( $rec );  
                         },  
378                          recode => $input->{recode},                          recode => $input->{recode},
379                          stats => $stats,                          stats => $stats,
380                          modify_records => $input->{modify_records},                          modify_records => $input->{modify_records},
381                            modify_file => $input->{modify_file},
382                            input_config => $input,
383                  );                  );
384                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
385    
386                    if (defined( $input->{lookup} )) {
387                            $log->warn("$database/$input_name has depriciated lookup definition, removing it...");
388                            delete( $input->{lookup} );
389                    }
390    
391                    my $lookup_coderef;
392    
393                    if (@lookups) {
394    
395                            my $rules = $parser->lookup_create_rules($database, $input) || $log->logdie("no rules found for $database/$input");
396    
397                            $lookup_coderef = sub {
398                                    my $rec = shift || die "need rec!";
399                                    my $mfn = $rec->{'000'}->[0] || die "need mfn in 000";
400    
401                                    WebPAC::Normalize::data_structure(
402                                            row => $rec,
403                                            rules => $rules,
404                                            config => create_ds_config( $db_config, $database, $input, $mfn ),
405                                    );
406    
407                                    #warn "current lookup: ", dump(WebPAC::Normalize::_get_lookup());
408                            };
409    
410                            WebPAC::Normalize::_set_lookup( undef );
411    
412                            $log->debug("created lookup_coderef using:\n$rules");
413    
414                    };
415    
416                    my $lookup_jar;
417    
418                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
419                          path => $input->{path},                          path => $input->{path},
420                          code_page => $input->{encoding},        # database encoding                          code_page => $input->{encoding},        # database encoding
421                            lookup_coderef => $lookup_coderef,
422                            lookup => $lookup_jar,
423                          %{ $input },                          %{ $input },
424                  );                          load_row => sub {
425                                    my $a = shift;
426                  my @norm_array = ref($input->{normalize}) eq 'ARRAY' ?                                  return $store->load_row(
427                          @{ $input->{normalize} } : ( $input->{normalize} );                                          database => $database,
428                                            input => $input_name,
429                  if ($marc_normalize) {                                          id => $a->{id},
430                          @norm_array = ( {                                  );
431                                  path => $marc_normalize,                          },
432                                  output => $marc_output || 'out/marc/' . $database . '-' . $input->{name} . '.marc',                          save_row => sub {
433                          } );                                  my $a = shift;
434                  }                                  return $store->save_row(
435                                            database => $database,
436                                            input => $input_name,
437                                            id => $a->{id},
438                                            row => $a->{row},
439                                    );
440                            },
441    
442                  foreach my $normalize (@norm_array) {                  );
443    
444                          my $normalize_path = $normalize->{path} || $log->logdie("can't find normalize path in config");                  my $lookup_data = WebPAC::Normalize::_get_lookup();
445    
446                          $log->logdie("Found '$normalize_path' as normalization file which isn't supported any more!") unless ( $normalize_path =~ m!\.pl$!i );                  if (defined( $lookup_data->{$database}->{$input_name} )) {
447                            $log->debug("created following lookups: ", sub { dump( $lookup_data ) } );
448    
449                          my $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";                          foreach my $key (keys %{ $lookup_data->{$database}->{$input_name} }) {
450                                    $store->save_lookup(
451                                            database => $database,
452                                            input => $input_name,
453                                            key => $key,
454                                            data => $lookup_data->{$database}->{$input_name}->{$key},
455                                    );
456                            }
457                    }
458    
459                          $log->info("Using $normalize_path for normalization...");                  my $report_fh;
460                    if ($stats || $validate) {
461                            my $path = "out/report/${database}-${input_name}.txt";
462                            open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
463    
464                            print $report_fh "Report for database '$database' input '$input_name' records ",
465                                    $offset || 1, "-", $limit || $input->{limit} || $maxmfn, "\n\n";
466                            $log->info("Generating report file $path");
467    
468                            if ( $validate ) {
469                                    $validate->read_validate_file( $validate->fill_in( $validate_path, database => $database, input => $input_name ) ) if ( $validate_path );
470                                    $validate->read_validate_delimiters_file( $validate->fill_in( $validate_delimiters_path, database => $database, input => $input_name ) ) if ( $validate_delimiters_path );
471                            }
472                    }
473    
474                          my $marc = new WebPAC::Output::MARC(                  my $marc;
475                                  path => $normalize->{output},                  if ($marc_generate && $parser->have_rules( 'marc', $database, $input_name )) {
476                            $marc = new WebPAC::Output::MARC(
477                                    path => "out/marc/${database}-${input_name}.marc",
478                                  lint => $marc_lint,                                  lint => $marc_lint,
479                                  dump => $marc_dump,                                  dump => $marc_dump,
480                          ) if ($normalize->{output});                          );
481                    }
482    
483                          # reset position in database                  my $rules = $parser->normalize_rules($database,$input_name) || $log->logdie("no normalize rules found for $database/$input_name");
484                          $input_db->seek(1);                  $log->debug("parsed normalize rules:\n$rules");
485    
486                          foreach my $pos ( 0 ... $input_db->size ) {                  # reset position in database
487                    $input_db->seek(1);
488    
489                                  my $row = $input_db->fetch || next;                  # generate name of config key for indexer (strip everything after -)
490                    my $indexer_config = $use_indexer;
491                    $indexer_config =~ s/^(\w+)-?.*$/$1/g if ($indexer_config);
492    
493                    my $lookup_hash;
494                    my $depends = $parser->depends($database,$input_name);
495            
496                    if ($depends) {
497                            $log->debug("$database/$input_name depends on: ", dump($depends)) if ($depends);
498                            $log->logdie("parser->depends didn't return HASH") unless (ref($depends) eq 'HASH');
499    
500                            foreach my $db (keys %$depends) {
501                                    foreach my $i (keys %{$depends->{$db}}) {
502                                            foreach my $k (keys %{$depends->{$db}->{$i}}) {
503                                                    my $t = time();
504                                                    $log->debug("loading lookup $db/$i");
505                                                    $lookup_hash->{$db}->{$i}->{$k} = $store->load_lookup(
506                                                            database => $db,
507                                                            input => $i,
508                                                            key => $k,
509                                                    );
510                                                    $log->debug(sprintf("lookup $db/$i took %.2fs", time() - $t));
511                                            }
512                                    }
513                            }
514    
515                                  my $mfn = $row->{'000'}->[0];                          $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
516                    }
517    
518                                  if (! $mfn || $mfn !~ m#^\d+$#) {  
519                                          $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");                  # setup input name for all output filters
520                                          $mfn = $pos;                  foreach my $out ( @output_modules ) {
521                                          push @{ $row->{'000'} }, $pos;                          if ( $out->can('input') ) {
522                                  }                                  $out->input( $input_name );
523                            } else {
524                                    $log->warn("output filter ",ref($out)," doesn't support input name");
525                            }
526                    }
527    
528    
529                                  if ($validate) {                  foreach my $pos ( 0 ... $input_db->size ) {
                                         my @errors = $validate->validate_errors( $row );  
                                         $log->error( "MFN $mfn validation errors:\n", join("\n", @errors) ) if (@errors);  
                                 }  
530    
531                                  my $ds_config = dclone($db_config);                          my $row = $input_db->fetch || next;
532    
533                                  # default values -> database key                          $total_rows++;
                                 $ds_config->{_} = $database;  
534    
535                                  # current mfn                          my $mfn = $row->{'000'}->[0];
                                 $ds_config->{_mfn} = $mfn;  
536    
537                                  # attach current input                          if (! $mfn || $mfn !~ m{^\d+$}) {
538                                  $ds_config->{input} = $input;                                  $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");
539                                    $mfn = $pos;
540                                    push @{ $row->{'000'} }, $pos;
541                            }
542    
                                 my $ds = WebPAC::Normalize::data_structure(  
                                         row => $row,  
                                         rules => $rules,  
                                         lookup => $lookup ? $lookup->lookup_hash : undef,  
                                         config => $ds_config,  
                                         marc_encoding => 'utf-8',  
                                 );  
543    
544                                  $db->save_ds(                          if ($validate) {
545                                    if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
546                                            $log->error( "MFN $mfn validation error:\n",
547                                                    $validate->report_error( $errors )
548                                            );
549                                    }
550                                    next;   # validation doesn't create any output
551                            }
552    
553                            if ( my $ds = WebPAC::Normalize::data_structure(
554                                    row => $row,
555                                    rules => $rules,
556                                    lookup => $lookup_hash,
557                                    config => create_ds_config( $db_config, $database, $input, $mfn ),
558                                    marc_encoding => 'utf-8',
559                                    load_row_coderef => sub {
560                                            my ($database,$input,$mfn) = @_;
561                                            return $store->load_row(
562                                                    database => $database,
563                                                    input => $input,
564                                                    id => $mfn,
565                                            );
566                                    },
567                            ) ) { # if
568    
569                                    $log->debug("ds = ", sub { dump($ds) });
570    
571                                    $store->save_ds(
572                                            database => $database,
573                                            input => $input_name,
574                                          id => $mfn,                                          id => $mfn,
575                                          ds => $ds,                                          ds => $ds,
576                                          prefix => $input->{name},                                  ) if !$stats;
                                 ) if ($ds && !$stats);  
577    
578                                  $indexer->add(                                  $indexer->add(
579                                          id => $input->{name} . "/" . $mfn,                                          id => "${input_name}/${mfn}",
580                                          ds => $ds,                                          ds => $ds,
581                                          type => $config->{$use_indexer}->{type},                                          type => $config->get($indexer_config)->{type},
582                                  ) if ($indexer && $ds);                                  ) if $indexer;
583    
584                                  if ($marc) {                                  if ($marc) {
585                                          my $i = 0;                                          my $i = 0;
# Line 367  while (my ($database, $db_config) = each Line 588  while (my ($database, $db_config) = each
588                                                  $marc->add(                                                  $marc->add(
589                                                          id => $mfn . ( $i ? "/$i" : '' ),                                                          id => $mfn . ( $i ? "/$i" : '' ),
590                                                          fields => $fields,                                                          fields => $fields,
591                                                          leader => WebPAC::Normalize::marc_leader(),                                                          leader => WebPAC::Normalize::_get_marc_leader(),
592                                                          row => $row,                                                          row => $row,
593                                                  );                                                  );
594                                                  $i++;                                                  $i++;
# Line 376  while (my ($database, $db_config) = each Line 597  while (my ($database, $db_config) = each
597                                          $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);                                          $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
598                                  }                                  }
599    
600                                  $total_rows++;                                  foreach my $out ( @output_modules ) {
601                                            $out->add( $mfn, $ds ) if $out->can('add');
602                                    }
603    
604                            } else {
605                                    $log->warn("record $pos didn't produce any output after normalization rules!");
606                            }
607    
608                    }
609    
610                    if ($validate) {
611                            my $errors = $validate->report;
612                            if ($errors) {
613                                    $log->info("validation errors:\n$errors\n" );
614                                    print $report_fh "$errors\n" if ($report_fh);
615                          }                          }
616    
617                          $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";
618    
619                          # close MARC file                          # must be last thing that touches $validate for this input
620                          $marc->finish if ($marc);                          $validate->reset;
621                    }
622    
623                    if ($stats) {
624                            my $s = $input_db->stats;
625                            $log->info("statistics of fields usage:\n$s");
626                            print $report_fh "Statistics of fields usage:\n$s" if ($report_fh);
627                  }                  }
628    
629                    # close MARC file
630                    $marc->finish if ($marc);
631    
632                    # close report
633                    close($report_fh) if ($report_fh);
634          }          }
635    
636          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));
637    
638            foreach my $out ( @output_modules ) {
639                    $out->finish if $out->can('finish');
640            }
641    
642          my $dt = time() - $start_t;          my $dt = time() - $start_t;
643          $log->info("$total_rows records ", $indexer ? "indexed " : "",          $log->info("$total_rows records ", $indexer ? "indexed " : "",
644                  sprintf("in %.2f sec [%.2f rec/sec]",                  sprintf("in %.2f sec [%.2f rec/sec]",
# Line 397  while (my ($database, $db_config) = each Line 646  while (my ($database, $db_config) = each
646                  )                  )
647          );          );
648    
         #  
         # 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}]");  
                         }  
                 }  
         }  
649    
650          # end forked process          # end forked process
651          if ($parallel) {          if ($parallel) {
# Line 429  if ($parallel) { Line 661  if ($parallel) {
661          $log->info("all parallel processes finished");          $log->info("all parallel processes finished");
662  }  }
663    
664  foreach my $link (@links) {  # save new delimiters if needed
665          $log->info("adding link $link->{from} -> $link->{to} [$link->{credit}]");  $validate->save_delimiters_templates if ( $validate_delimiters_path );
         $indexer->add_link( %{ $link } );  
 }  
666    
667    #
668    # handle links or merge after indexing
669    #
670    
671    if ($merge) {
672            print $estcmd_fh 'sudo /etc/init.d/hyperestraier start',$/;
673            close($estcmd_fh);
674            chmod 0700, $estcmd_path || $log->warn("can't chmod 0700 $estcmd_path: $!");
675            system $estcmd_path;
676    } else {
677            foreach my $link (@links) {
678                    $log->logdie("coderef in link ", Dumper($link), " is ", ref($link), " and not CODE") unless (ref($link) eq 'CODE');
679                    $link->();
680            }
681    }
Legend:
Removed from v.606  
changed lines
  Added in v.969
  ViewVC Help
Powered by ViewVC 1.1.26