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