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