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