/[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 916 by dpavlin, Tue Oct 30 20:32:16 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" => \$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          # now WebPAC::Store          # store Hyper Estraier links to other databases
270          #          #
271          my $abs_path = abs_path($0);          if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {
272          $abs_path =~ s#/[^/]*$#/#;                  foreach my $link (@{ $db_config->{links} }) {
273                            if ($use_indexer eq 'hyperestraier') {
274          my $db_path = $config->{webpac}->{db_path} . '/' . $database;                                  if ($merge) {
275                                            print $estcmd_fh 'sudo -u www-data estcmd merge ' . $database . ' ' . $link->{to},$/;
276          if ($clean) {                                  } else {
277                  $log->info("creating new database '$database' in $db_path");                                          $log->info("saving link $database -> $link->{to} [$link->{credit}]");
278                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");                                          push @links, sub {
279          } else {                                                  $log->info("adding link $database -> $link->{to} [$link->{credit}]");
280                  $log->info("working on database '$database' in $db_path");                                                  $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          my $db = new WebPAC::Store(          #
296                  path => $db_path,          # now WebPAC::Store
297                  database => $database,          #
298            my $store = new WebPAC::Store({
299                  debug => $debug,                  debug => $debug,
300          );          });
301    
302            #
303            # prepare output
304            #
305            my @outputs;
306            if (defined( $db_config->{output} )) {
307                    my $module = $db_config->{output}->{module} || $log->logdie("need module in output section of $database");
308                    $module = 'WebPAC::Output::' . $module unless $module =~ m/::/;
309                    $log->debug("loading output module $module");
310                    eval "require $module";
311                    $db_config->{output}->{database} = $database;
312                    $log->debug("calling $module->new(",dump( $db_config->{output} ),")");
313                    my $out = new $module->new( $db_config->{output} );
314                    $out->init;
315                    push @outputs, $out;
316            }
317    
318    
319          #          #
# Line 237  while (my ($database, $db_config) = each Line 329  while (my ($database, $db_config) = each
329                  $log->info("database $database doesn't have inputs defined");                  $log->info("database $database doesn't have inputs defined");
330          }          }
331    
         my @supported_inputs = keys %{ $config->{webpac}->{inputs} };  
   
332          foreach my $input (@inputs) {          foreach my $input (@inputs) {
333    
334                  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));
335    
336                    next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
337    
338                  my $type = lc($input->{type});                  my $type = lc($input->{type});
339    
340                  die "I know only how to handle input types ", join(",", @supported_inputs), " not '$type'!\n" unless (grep(/$type/, @supported_inputs));                  die "I know only how to handle input types ", join(",", $config->webpac('inputs') ), " not '$type'!\n" unless (grep(/$type/, $config->webpac('inputs')));
341    
342                  my $lookup;                  my $input_module = $config->webpac('inputs')->{$type};
                 if ($input->{lookup}) {  
                         $lookup = new WebPAC::Lookup(  
                                 lookup_file => $input->{lookup},  
                         );  
                         delete( $input->{lookup} );  
                 }  
343    
344                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my @lookups = $parser->have_lookup_create($database, $input);
345    
346                  $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",
347                          $input->{lookup} ? "lookup '$input->{lookup}'" : ""                          @lookups ? " creating lookups: ".join(", ", @lookups) : ""
348                  );                  );
349    
350                    if ($stats) {
351                            # disable modification of records if --stats is in use
352                            delete($input->{modify_records});
353                            delete($input->{modify_file});
354                    }
355    
356                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
357                          module => $input_module,                          module => $input_module,
358                          encoding => $config->{webpac}->{webpac_encoding},                          encoding => $config->webpac('webpac_encoding'),
359                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
360                          offset => $offset,                          offset => $offset,
                         lookup_coderef => sub {  
                                 my $rec = shift || return;  
                                 $lookup->add( $rec );  
                         },  
361                          recode => $input->{recode},                          recode => $input->{recode},
362                          stats => $stats,                          stats => $stats,
363                          modify_records => $input->{modify_records},                          modify_records => $input->{modify_records},
364                            modify_file => $input->{modify_file},
365                            input_config => $input,
366                  );                  );
367                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
368    
369                    if (defined( $input->{lookup} )) {
370                            $log->warn("$database/$input_name has depriciated lookup definition, removing it...");
371                            delete( $input->{lookup} );
372                    }
373    
374                    my $lookup_coderef;
375    
376                    if (@lookups) {
377    
378                            my $rules = $parser->lookup_create_rules($database, $input) || $log->logdie("no rules found for $database/$input");
379    
380                            $lookup_coderef = sub {
381                                    my $rec = shift || die "need rec!";
382                                    my $mfn = $rec->{'000'}->[0] || die "need mfn in 000";
383    
384                                    WebPAC::Normalize::data_structure(
385                                            row => $rec,
386                                            rules => $rules,
387                                            config => create_ds_config( $db_config, $database, $input, $mfn ),
388                                    );
389    
390                                    #warn "current lookup: ", dump(WebPAC::Normalize::_get_lookup());
391                            };
392    
393                            WebPAC::Normalize::_set_lookup( undef );
394    
395                            $log->debug("created lookup_coderef using:\n$rules");
396    
397                    };
398    
399                    my $lookup_jar;
400    
401                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
402                          path => $input->{path},                          path => $input->{path},
403                          code_page => $input->{encoding},        # database encoding                          code_page => $input->{encoding},        # database encoding
404                            lookup_coderef => $lookup_coderef,
405                            lookup => $lookup_jar,
406                          %{ $input },                          %{ $input },
407                            load_row => sub {
408                                    my $a = shift;
409                                    return $store->load_row(
410                                            database => $database,
411                                            input => $input_name,
412                                            id => $a->{id},
413                                    );
414                            },
415                            save_row => sub {
416                                    my $a = shift;
417                                    return $store->save_row(
418                                            database => $database,
419                                            input => $input_name,
420                                            id => $a->{id},
421                                            row => $a->{row},
422                                    );
423                            },
424    
425                  );                  );
426    
427                  my @norm_array = ref($input->{normalize}) eq 'ARRAY' ?                  my $lookup_data = WebPAC::Normalize::_get_lookup();
428                          @{ $input->{normalize} } : ( $input->{normalize} );  
429                    if (defined( $lookup_data->{$database}->{$input_name} )) {
430                            $log->debug("created following lookups: ", sub { dump( $lookup_data ) } );
431    
432                  if ($marc_normalize) {                          foreach my $key (keys %{ $lookup_data->{$database}->{$input_name} }) {
433                          @norm_array = ( {                                  $store->save_lookup(
434                                  path => $marc_normalize,                                          database => $database,
435                                  output => $marc_output || 'out/marc/' . $database . '-' . $input->{name} . '.marc',                                          input => $input_name,
436                          } );                                          key => $key,
437                                            data => $lookup_data->{$database}->{$input_name}->{$key},
438                                    );
439                            }
440                  }                  }
441    
442                  foreach my $normalize (@norm_array) {                  my $report_fh;
443                    if ($stats || $validate) {
444                            my $path = "out/report/${database}-${input_name}.txt";
445                            open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
446    
447                            print $report_fh "Report for database '$database' input '$input_name' records ",
448                                    $offset || 1, "-", $limit || $input->{limit} || $maxmfn, "\n\n";
449                            $log->info("Generating report file $path");
450    
451                            if ( $validate ) {
452                                    $validate->read_validate_file( $validate->fill_in( $validate_path, database => $database, input => $input_name ) ) if ( $validate_path );
453                                    $validate->read_validate_delimiters_file( $validate->fill_in( $validate_delimiters_path, database => $database, input => $input_name ) ) if ( $validate_delimiters_path );
454                            }
455                    }
456    
457                          my $normalize_path = $normalize->{path} || $log->logdie("can't find normalize path in config");                  my $marc;
458                    if ($marc_generate && $parser->have_rules( 'marc', $database, $input_name )) {
459                            $marc = new WebPAC::Output::MARC(
460                                    path => "out/marc/${database}-${input_name}.marc",
461                                    lint => $marc_lint,
462                                    dump => $marc_dump,
463                            );
464                    }
465    
466                          $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");
467                    $log->debug("parsed normalize rules:\n$rules");
468    
469                          my $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";                  # reset position in database
470                    $input_db->seek(1);
471    
472                          $log->info("Using $normalize_path for normalization...");                  # generate name of config key for indexer (strip everything after -)
473                    my $indexer_config = $use_indexer;
474                    $indexer_config =~ s/^(\w+)-?.*$/$1/g if ($indexer_config);
475    
476                    my $lookup_hash;
477                    my $depends = $parser->depends($database,$input_name);
478            
479                    if ($depends) {
480                            $log->debug("$database/$input_name depends on: ", dump($depends)) if ($depends);
481                            $log->logdie("parser->depends didn't return HASH") unless (ref($depends) eq 'HASH');
482    
483                            foreach my $db (keys %$depends) {
484                                    foreach my $i (keys %{$depends->{$db}}) {
485                                            foreach my $k (keys %{$depends->{$db}->{$i}}) {
486                                                    my $t = time();
487                                                    $log->debug("loading lookup $db/$i");
488                                                    $lookup_hash->{$db}->{$i}->{$k} = $store->load_lookup(
489                                                            database => $db,
490                                                            input => $i,
491                                                            key => $k,
492                                                    );
493                                                    $log->debug(sprintf("lookup $db/$i took %.2fs", time() - $t));
494                                            }
495                                    }
496                            }
497    
498                          my $marc = new WebPAC::Output::MARC(                          $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
499                                  path => $normalize->{output},                  }
                                 lint => $marc_lint,  
                                 dump => $marc_dump,  
                         ) if ($normalize->{output});  
500    
                         # reset position in database  
                         $input_db->seek(1);  
501    
502                          foreach my $pos ( 0 ... $input_db->size ) {                  foreach my $pos ( 0 ... $input_db->size ) {
503    
504                                  my $row = $input_db->fetch || next;                          my $row = $input_db->fetch || next;
505    
506                                  my $mfn = $row->{'000'}->[0];                          $total_rows++;
507    
508                                  if (! $mfn || $mfn !~ m#^\d+$#) {                          my $mfn = $row->{'000'}->[0];
509                                          $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");  
510                                          $mfn = $pos;                          if (! $mfn || $mfn !~ m{^\d+$}) {
511                                          push @{ $row->{'000'} }, $pos;                                  $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");
512                                  }                                  $mfn = $pos;
513                                    push @{ $row->{'000'} }, $pos;
514                            }
515    
516    
517                                  if ($validate) {                          if ($validate) {
518                                          my @errors = $validate->validate_errors( $row );                                  if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
519                                          $log->error( "MFN $mfn validation errors:\n", join("\n", @errors) ) if (@errors);                                          $log->error( "MFN $mfn validation error:\n",
520                                                    $validate->report_error( $errors )
521                                            );
522                                  }                                  }
523                                    next;   # validation doesn't create any output
524                            }
525    
526                                  my $ds_config = dclone($db_config);                          my $ds = WebPAC::Normalize::data_structure(
527                                    row => $row,
528                                  # default values -> database key                                  rules => $rules,
529                                  $ds_config->{_} = $database;                                  lookup => $lookup_hash,
530                                    config => create_ds_config( $db_config, $database, $input, $mfn ),
531                                    marc_encoding => 'utf-8',
532                                    load_row_coderef => sub {
533                                            my ($database,$input,$mfn) = @_;
534                                            return $store->load_row(
535                                                    database => $database,
536                                                    input => $input,
537                                                    id => $mfn,
538                                            );
539                                    },
540                            );
541    
542                                  # current mfn                          $log->debug("ds = ", sub { dump($ds) }) if ($ds);
                                 $ds_config->{_mfn} = $mfn;  
543    
544                                  # attach current input                          $store->save_ds(
545                                  $ds_config->{input} = $input;                                  database => $database,
546                                    input => $input_name,
547                                    id => $mfn,
548                                    ds => $ds,
549                            ) if ($ds && !$stats);
550    
551                            $indexer->add(
552                                    id => "${input_name}/${mfn}",
553                                    ds => $ds,
554                                    type => $config->get($indexer_config)->{type},
555                            ) if ($indexer && $ds);
556    
557                            if ($marc) {
558                                    my $i = 0;
559    
560                                    while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {
561                                            $marc->add(
562                                                    id => $mfn . ( $i ? "/$i" : '' ),
563                                                    fields => $fields,
564                                                    leader => WebPAC::Normalize::_get_marc_leader(),
565                                                    row => $row,
566                                            );
567                                            $i++;
568                                    }
569    
570                                  my $ds = WebPAC::Normalize::data_structure(                                  $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
571                                          row => $row,                          }
                                         rules => $rules,  
                                         lookup => $lookup ? $lookup->lookup_hash : undef,  
                                         config => $ds_config,  
                                         marc_encoding => 'utf-8',  
                                 );  
572    
573                                  $db->save_ds(                          foreach my $out ( @outputs ) {
574                                          id => $mfn,                                  $out->add( $mfn, $ds ) if $out->can('add');
575                                          ds => $ds,                          }
                                         prefix => $input->{name},  
                                 ) if ($ds && !$stats);  
   
                                 $indexer->add(  
                                         id => $input->{name} . "/" . $mfn,  
                                         ds => $ds,  
                                         type => $config->{$use_indexer}->{type},  
                                 ) if ($indexer && $ds);  
   
                                 if ($marc) {  
                                         my $i = 0;  
   
                                         while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {  
                                                 $marc->add(  
                                                         id => $mfn . ( $i ? "/$i" : '' ),  
                                                         fields => $fields,  
                                                         leader => WebPAC::Normalize::marc_leader(),  
                                                         row => $row,  
                                                 );  
                                                 $i++;  
                                         }  
576    
577                                          $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);                  }
                                 }  
578    
579                                  $total_rows++;                  if ($validate) {
580                            my $errors = $validate->report;
581                            if ($errors) {
582                                    $log->info("validation errors:\n$errors\n" );
583                                    print $report_fh "$errors\n" if ($report_fh);
584                          }                          }
585    
586                          $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";
587    
588                          # close MARC file                          # must be last thing that touches $validate for this input
589                          $marc->finish if ($marc);                          $validate->reset;
590                    }
591    
592                    if ($stats) {
593                            my $s = $input_db->stats;
594                            $log->info("statistics of fields usage:\n$s");
595                            print $report_fh "Statistics of fields usage:\n$s" if ($report_fh);
596                  }                  }
597    
598                    # close MARC file
599                    $marc->finish if ($marc);
600    
601                    # close report
602                    close($report_fh) if ($report_fh);
603          }          }
604    
605          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));
606    
607            foreach my $out ( @outputs ) {
608                    $out->finish if $out->can('finish');
609            }
610    
611          my $dt = time() - $start_t;          my $dt = time() - $start_t;
612          $log->info("$total_rows records ", $indexer ? "indexed " : "",          $log->info("$total_rows records ", $indexer ? "indexed " : "",
613                  sprintf("in %.2f sec [%.2f rec/sec]",                  sprintf("in %.2f sec [%.2f rec/sec]",
# Line 397  while (my ($database, $db_config) = each Line 615  while (my ($database, $db_config) = each
615                  )                  )
616          );          );
617    
         #  
         # 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}]");  
                         }  
                 }  
         }  
618    
619          # end forked process          # end forked process
620          if ($parallel) {          if ($parallel) {
# Line 429  if ($parallel) { Line 630  if ($parallel) {
630          $log->info("all parallel processes finished");          $log->info("all parallel processes finished");
631  }  }
632    
633  foreach my $link (@links) {  # save new delimiters if needed
634          $log->info("adding link $link->{from} -> $link->{to} [$link->{credit}]");  $validate->save_delimiters_templates if ( $validate_delimiters_path );
         $indexer->add_link( %{ $link } );  
 }  
635    
636    #
637    # handle links or merge after indexing
638    #
639    
640    if ($merge) {
641            print $estcmd_fh 'sudo /etc/init.d/hyperestraier start',$/;
642            close($estcmd_fh);
643            chmod 0700, $estcmd_path || $log->warn("can't chmod 0700 $estcmd_path: $!");
644            system $estcmd_path;
645    } else {
646            foreach my $link (@links) {
647                    $log->logdie("coderef in link ", Dumper($link), " is ", ref($link), " and not CODE") unless (ref($link) eq 'CODE');
648                    $link->();
649            }
650    }
Legend:
Removed from v.606  
changed lines
  Added in v.916
  ViewVC Help
Powered by ViewVC 1.1.26