/[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 851 by dpavlin, Sun May 27 11:14:40 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  =item --validate-delimiters path/to/validate_delimiters_file
72    
73  This option specifies normalisation file for MARC creation  this option is used with C<--validate> to turn on extra validation of
74    delimiters. If file is non existant, it will be created on first run.
75    
76  =item --marc-output out/marc/test.marc  =item --marc-generate
77    
78  Optional path to output file  Generate MARC file. This will automatically be on if file contains C<marc*> directives.
79    You can use this option as C<--no-marc-generate> to disable MARC generation.
80    
81  =item --marc-lint  =item --marc-lint
82    
83  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
84  messages with C<--no-marc-lint>.  messages with C<--no-marc-lint>.
85    
86  =item --marc-dump  =item --marc-dump
# Line 89  Force dump or input and marc record for Line 92  Force dump or input and marc record for
92  Run databases in parallel (aproximatly same as number of processors in  Run databases in parallel (aproximatly same as number of processors in
93  machine if you want to use full load)  machine if you want to use full load)
94    
95    =item --only-links
96    
97    Create just links
98    
99    =item --merge
100    
101    Create merged index of databases which have links
102    
103  =back  =back
104    
105  =cut  =cut
# Line 97  my $offset; Line 108  my $offset;
108  my $limit;  my $limit;
109    
110  my $clean = 0;  my $clean = 0;
111  my $config = 'conf/config.yml';  my $config_path;
112  my $debug = 0;  my $debug = 0;
113  my $only_filter;  my $only_filter;
114  my $stats = 0;  my $stats = 0;
115  my $validate_path;  my $validate_path;
116  my ($marc_normalize, $marc_output);  my $validate_delimiters_path;
117    my $marc_generate = 1;
118  my $marc_lint = 1;  my $marc_lint = 1;
119  my $marc_dump = 0;  my $marc_dump = 0;
   
120  my $parallel = 0;  my $parallel = 0;
121    my $only_links = 0;
122    my $merge = 0;
123    my $help;
124    
125    my $log = _new WebPAC::Common()->_get_logger();
126    
127  GetOptions(  GetOptions(
128          "limit=i" => \$limit,          "limit=i" => \$limit,
# Line 114  GetOptions( Line 130  GetOptions(
130          "clean" => \$clean,          "clean" => \$clean,
131          "one=s" => \$only_filter,          "one=s" => \$only_filter,
132          "only=s" => \$only_filter,          "only=s" => \$only_filter,
133          "config" => \$config,          "config" => \$config_path,
134          "debug+" => \$debug,          "debug+" => \$debug,
135          "stats" => \$stats,          "stats" => \$stats,
136          "validate=s" => \$validate_path,          "validate=s" => \$validate_path,
137          "marc-normalize=s" => \$marc_normalize,          "validate-delimiters=s" => \$validate_delimiters_path,
138          "marc-output=s" => \$marc_output,          "marc-generate!" => \$marc_generate,
139          "marc-lint!" => \$marc_lint,          "marc-lint!" => \$marc_lint,
140          "marc-dump!" => \$marc_dump,          "marc-dump!" => \$marc_dump,
141          "parallel=i" => \$parallel,          "parallel=i" => \$parallel,
142            "only-links!" => \$only_links,
143            "merge" => \$merge,
144            "help" => \$help,
145  );  );
146    
147  $config = LoadFile($config);  $marc_generate = 0 if ( $validate_delimiters_path );
148    
149  print "config = ",dump($config) if ($debug);  pod2usage(-verbose => 2) if ($help);
150    
151  die "no databases in config file!\n" unless ($config->{databases});  my $config = new WebPAC::Config( path => $config_path );
152    
153    #print "config = ",dump($config) if ($debug);
154    
155    die "no databases in config file!\n" unless ($config->databases);
156    
 my $log = _new WebPAC::Common()->_get_logger();  
157  $log->info( "-" x 79 );  $log->info( "-" x 79 );
158    
159    my $log_file = 'log';
160    
161    if (-e $log_file ) {    # && -s $log_file > 5 * 1024 * 1024) {
162            $log->info("moved old log with ", -s $log_file, " bytes to '${log_file}.old'");
163            rename $log_file, "${log_file}.old" || $log->logwarn("can't rename $log_file to ${log_file}.old: $!");
164    }
165    
166    my $estcmd_fh;
167    my $estcmd_path = './estcmd-merge.sh';
168    if ($merge) {
169            open($estcmd_fh, '>', $estcmd_path) || $log->logdie("can't open $estcmd_path: $!");
170            print $estcmd_fh 'cd /data/estraier/_node/ || exit 1',$/;
171            print $estcmd_fh 'sudo /etc/init.d/hyperestraier stop',$/;
172            $log->info("created merge batch file $estcmd_path");
173    }
174    
175  my $validate;  my $validate;
176  $validate = new WebPAC::Validate(  $validate = new WebPAC::Validate(
177          path => $validate_path,          path => $validate_path,
178  ) if ($validate_path);          delimiters => $config->webpac('delimiters'),
179            delimiters_path => $validate_delimiters_path,
180    ) if ($validate_path || $validate_delimiters_path);
181    
182  my $use_indexer = $config->{use_indexer} || 'hyperestraier';  my $use_indexer = $config->use_indexer;
183    $stats ||= $validate;
184  if ($stats) {  if ($stats) {
185          $log->debug("option --stats disables update of indexing engine...");          $log->debug("disabled indexing for stats collection");
186          $use_indexer = undef;          $use_indexer = undef;
187  } else {  } else {
188          $log->info("using $use_indexer indexing engine...");          $log->info("using $use_indexer indexing engine...");
189  }  }
190    
191  # disable indexing when creating marc  # parse normalize files and create source files for lookup and normalization
192  $use_indexer = undef if ($marc_normalize);  
193    my $parser = new WebPAC::Parser( config => $config );
194    
195  my $total_rows = 0;  my $total_rows = 0;
196  my $start_t = time();  my $start_t = time();
197    
198  my @links;  my @links;
 my $indexer;  
199    
200  if ($parallel) {  if ($parallel) {
201          $log->info("Using $parallel processes for speedup");          $log->info("Using $parallel processes for speedup");
202          Proc::Queue::size($parallel);          Proc::Queue::size($parallel);
203  }  }
204    
205  while (my ($database, $db_config) = each %{ $config->{databases} }) {  sub create_ds_config {
206            my ($db_config, $database, $input, $mfn) = @_;
207            my $c = dclone( $db_config );
208            $c->{_} = $database || $log->logconfess("need database");
209            $c->{_mfn} = $mfn || $log->logconfess("need mfn");
210            $c->{input} = $input || $log->logconfess("need input");
211            return $c;
212    }
213    
214    while (my ($database, $db_config) = each %{ $config->databases }) {
215    
216          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);
217          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 225  while (my ($database, $db_config) = each
225                  }                  }
226          }          }
227    
228          if ($use_indexer) {          my $indexer;
229                  my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");          if ($use_indexer && $parser->have_rules( 'search', $database )) {
230    
231                    my $cfg_name = $use_indexer;
232                    $cfg_name =~ s/\-.*$//;
233    
234                    my $indexer_config = $config->get( $cfg_name ) || $log->logdie("can't find '$cfg_name' part in confguration");
235                  $indexer_config->{database} = $database;                  $indexer_config->{database} = $database;
236                  $indexer_config->{clean} = $clean;                  $indexer_config->{clean} = $clean;
237                  $indexer_config->{label} = $db_config->{name};                  $indexer_config->{label} = $db_config->{name};
238    
239                    # force clean if database has links
240                    $indexer_config->{clean} = 1 if ($db_config->{links});
241    
242                  if ($use_indexer eq 'hyperestraier') {                  if ($use_indexer eq 'hyperestraier') {
243    
244                          # open Hyper Estraier database                          # open Hyper Estraier database
245                          use WebPAC::Output::Estraier '0.10';                          use WebPAC::Output::Estraier '0.10';
246                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
247                                    
248                    } elsif ($use_indexer eq 'hyperestraier-native') {
249    
250                            # open Hyper Estraier database
251                            use WebPAC::Output::EstraierNative;
252                            $indexer = new WebPAC::Output::EstraierNative( %{ $indexer_config } );
253    
254                  } elsif ($use_indexer eq 'kinosearch') {                  } elsif ($use_indexer eq 'kinosearch') {
255    
256                          # open KinoSearch                          # open KinoSearch
# Line 203  while (my ($database, $db_config) = each Line 267  while (my ($database, $db_config) = each
267    
268    
269          #          #
270            # store Hyper Estraier links to other databases
271            #
272            if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {
273                    foreach my $link (@{ $db_config->{links} }) {
274                            if ($use_indexer eq 'hyperestraier') {
275                                    if ($merge) {
276                                            print $estcmd_fh 'sudo -u www-data estcmd merge ' . $database . ' ' . $link->{to},$/;
277                                    } else {
278                                            $log->info("saving link $database -> $link->{to} [$link->{credit}]");
279                                            push @links, sub {
280                                                    $log->info("adding link $database -> $link->{to} [$link->{credit}]");
281                                                    $indexer->add_link(
282                                                            from => $database,
283                                                            to => $link->{to},
284                                                            credit => $link->{credit},
285                                                    );
286                                            };
287                                    }
288                            } else {
289                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
290                            }
291                    }
292            }
293            next if ($only_links);
294    
295    
296            #
297          # now WebPAC::Store          # now WebPAC::Store
298          #          #
299          my $abs_path = abs_path($0);          my $abs_path = abs_path($0);
300          $abs_path =~ s#/[^/]*$#/#;          $abs_path =~ s#/[^/]*$#/#;
301    
302          my $db_path = $config->{webpac}->{db_path} . '/' . $database;          my $db_path = $config->webpac('db_path');
303    
304          if ($clean) {          if ($clean) {
305                  $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 308  while (my ($database, $db_config) = each
308                  $log->info("working on database '$database' in $db_path");                  $log->info("working on database '$database' in $db_path");
309          }          }
310    
311          my $db = new WebPAC::Store(          my $store = new WebPAC::Store(
312                  path => $db_path,                  path => $db_path,
                 database => $database,  
313                  debug => $debug,                  debug => $debug,
314          );          );
315    
# Line 237  while (my ($database, $db_config) = each Line 327  while (my ($database, $db_config) = each
327                  $log->info("database $database doesn't have inputs defined");                  $log->info("database $database doesn't have inputs defined");
328          }          }
329    
         my @supported_inputs = keys %{ $config->{webpac}->{inputs} };  
   
330          foreach my $input (@inputs) {          foreach my $input (@inputs) {
331    
332                  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));
333    
334                    next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
335    
336                  my $type = lc($input->{type});                  my $type = lc($input->{type});
337    
338                  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')));
339    
340                  my $lookup;                  my $input_module = $config->webpac('inputs')->{$type};
                 if ($input->{lookup}) {  
                         $lookup = new WebPAC::Lookup(  
                                 lookup_file => $input->{lookup},  
                         );  
                         delete( $input->{lookup} );  
                 }  
341    
342                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my @lookups = $parser->have_lookup_create($database, $input);
343    
344                  $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",
345                          $input->{lookup} ? "lookup '$input->{lookup}'" : ""                          @lookups ? " creating lookups: ".join(", ", @lookups) : ""
346                  );                  );
347    
348                    if ($stats) {
349                            # disable modification of records if --stats is in use
350                            delete($input->{modify_records});
351                            delete($input->{modify_file});
352                    }
353    
354                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
355                          module => $input_module,                          module => $input_module,
356                          encoding => $config->{webpac}->{webpac_encoding},                          encoding => $config->webpac('webpac_encoding'),
357                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
358                          offset => $offset,                          offset => $offset,
                         lookup_coderef => sub {  
                                 my $rec = shift || return;  
                                 $lookup->add( $rec );  
                         },  
359                          recode => $input->{recode},                          recode => $input->{recode},
360                          stats => $stats,                          stats => $stats,
361                          modify_records => $input->{modify_records},                          modify_records => $input->{modify_records},
362                            modify_file => $input->{modify_file},
363                  );                  );
364                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
365    
366                    if (defined( $input->{lookup} )) {
367                            $log->warn("$database/$input_name has depriciated lookup definition, removing it...");
368                            delete( $input->{lookup} );
369                    }
370    
371                    my $lookup_coderef;
372    
373                    if (@lookups) {
374    
375                            my $rules = $parser->lookup_create_rules($database, $input) || $log->logdie("no rules found for $database/$input");
376    
377                            $lookup_coderef = sub {
378                                    my $rec = shift || die "need rec!";
379                                    my $mfn = $rec->{'000'}->[0] || die "need mfn in 000";
380    
381                                    WebPAC::Normalize::data_structure(
382                                            row => $rec,
383                                            rules => $rules,
384                                            config => create_ds_config( $db_config, $database, $input, $mfn ),
385                                    );
386    
387                                    #warn "current lookup: ", dump(WebPAC::Normalize::_get_lookup());
388                            };
389    
390                            WebPAC::Normalize::_set_lookup( undef );
391    
392                            $log->debug("created lookup_coderef using:\n$rules");
393    
394                    };
395    
396                    my $lookup_jar;
397    
398                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
399                          path => $input->{path},                          path => $input->{path},
400                          code_page => $input->{encoding},        # database encoding                          code_page => $input->{encoding},        # database encoding
401                            lookup_coderef => $lookup_coderef,
402                            lookup => $lookup_jar,
403                          %{ $input },                          %{ $input },
404                  );                          load_row => sub {
405                                    my $a = shift;
406                  my @norm_array = ref($input->{normalize}) eq 'ARRAY' ?                                  return $store->load_row(
407                          @{ $input->{normalize} } : ( $input->{normalize} );                                          database => $database,
408                                            input => $input_name,
409                  if ($marc_normalize) {                                          id => $a->{id},
410                          @norm_array = ( {                                  );
411                                  path => $marc_normalize,                          },
412                                  output => $marc_output || 'out/marc/' . $database . '-' . $input->{name} . '.marc',                          save_row => sub {
413                          } );                                  my $a = shift;
414                  }                                  return $store->save_row(
415                                            database => $database,
416                                            input => $input_name,
417                                            id => $a->{id},
418                                            row => $a->{row},
419                                    );
420                            },
421    
422                  foreach my $normalize (@norm_array) {                  );
423    
424                          my $normalize_path = $normalize->{path} || $log->logdie("can't find normalize path in config");                  my $lookup_data = WebPAC::Normalize::_get_lookup();
425    
426                          $log->logdie("Found '$normalize_path' as normalization file which isn't supported any more!") unless ( $normalize_path =~ m!\.pl$!i );                  if (defined( $lookup_data->{$database}->{$input_name} )) {
427                            $log->debug("created following lookups: ", sub { dump( $lookup_data ) } );
428    
429                          my $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";                          foreach my $key (keys %{ $lookup_data->{$database}->{$input_name} }) {
430                                    $store->save_lookup(
431                                            database => $database,
432                                            input => $input_name,
433                                            key => $key,
434                                            data => $lookup_data->{$database}->{$input_name}->{$key},
435                                    );
436                            }
437                    }
438    
439                          $log->info("Using $normalize_path for normalization...");                  my $report_fh;
440                    if ($stats || $validate) {
441                            my $path = "out/report/${database}-${input_name}.txt";
442                            open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
443    
444                            print $report_fh "Report for database '$database' input '$input_name' records ",
445                                    $offset || 1, "-", $limit || $input->{limit} || $maxmfn, "\n\n";
446                            $log->info("Generating report file $path");
447                    }
448    
449                          my $marc = new WebPAC::Output::MARC(                  my $marc;
450                                  path => $normalize->{output},                  if ($marc_generate && $parser->have_rules( 'marc', $database, $input_name )) {
451                            $marc = new WebPAC::Output::MARC(
452                                    path => "out/marc/${database}-${input_name}.marc",
453                                  lint => $marc_lint,                                  lint => $marc_lint,
454                                  dump => $marc_dump,                                  dump => $marc_dump,
455                          ) if ($normalize->{output});                          );
456                    }
457    
458                          # reset position in database                  my $rules = $parser->normalize_rules($database,$input_name) || $log->logdie("no normalize rules found for $database/$input_name");
459                          $input_db->seek(1);                  $log->debug("parsed normalize rules:\n$rules");
460    
461                          foreach my $pos ( 0 ... $input_db->size ) {                  # reset position in database
462                    $input_db->seek(1);
463    
464                                  my $row = $input_db->fetch || next;                  # generate name of config key for indexer (strip everything after -)
465                    my $indexer_config = $use_indexer;
466                    $indexer_config =~ s/^(\w+)-?.*$/$1/g if ($indexer_config);
467    
468                    my $lookup_hash;
469                    my $depends = $parser->depends($database,$input_name);
470            
471                    if ($depends) {
472                            $log->debug("$database/$input_name depends on: ", dump($depends)) if ($depends);
473                            $log->logdie("parser->depends didn't return HASH") unless (ref($depends) eq 'HASH');
474    
475                            foreach my $db (keys %$depends) {
476                                    foreach my $i (keys %{$depends->{$db}}) {
477                                            foreach my $k (keys %{$depends->{$db}->{$i}}) {
478                                                    my $t = time();
479                                                    $log->debug("loading lookup $db/$i");
480                                                    $lookup_hash->{$db}->{$i}->{$k} = $store->load_lookup(
481                                                            database => $db,
482                                                            input => $i,
483                                                            key => $k,
484                                                    );
485                                                    $log->debug(sprintf("lookup $db/$i took %.2fs", time() - $t));
486                                            }
487                                    }
488                            }
489    
490                                  my $mfn = $row->{'000'}->[0];                          $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
491                    }
492    
                                 if (! $mfn || $mfn !~ m#^\d+$#) {  
                                         $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");  
                                         $mfn = $pos;  
                                         push @{ $row->{'000'} }, $pos;  
                                 }  
493    
494                    foreach my $pos ( 0 ... $input_db->size ) {
495    
496                                  if ($validate) {                          my $row = $input_db->fetch || next;
                                         my @errors = $validate->validate_errors( $row );  
                                         $log->error( "MFN $mfn validation errors:\n", join("\n", @errors) ) if (@errors);  
                                 }  
497    
498                                  my $ds_config = dclone($db_config);                          $total_rows++;
499    
500                                  # default values -> database key                          my $mfn = $row->{'000'}->[0];
                                 $ds_config->{_} = $database;  
501    
502                                  # current mfn                          if (! $mfn || $mfn !~ m#^\d+$#) {
503                                  $ds_config->{_mfn} = $mfn;                                  $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");
504                                    $mfn = $pos;
505                                    push @{ $row->{'000'} }, $pos;
506                            }
507    
                                 # attach current input  
                                 $ds_config->{input} = $input;  
508    
509                                  my $ds = WebPAC::Normalize::data_structure(                          if ($validate) {
510                                          row => $row,                                  if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
511                                          rules => $rules,                                          $log->error( "MFN $mfn validation error:\n",
512                                          lookup => $lookup ? $lookup->lookup_hash : undef,                                                  $validate->report_error( $errors )
513                                          config => $ds_config,                                          );
514                                          marc_encoding => 'utf-8',                                  }
515                                  );                                  next;   # validation doesn't create any output
516                            }
517    
518                                  $db->save_ds(                          my $ds = WebPAC::Normalize::data_structure(
519                                          id => $mfn,                                  row => $row,
520                                          ds => $ds,                                  rules => $rules,
521                                          prefix => $input->{name},                                  lookup => $lookup_hash,
522                                  ) if ($ds && !$stats);                                  config => create_ds_config( $db_config, $database, $input, $mfn ),
523                                    marc_encoding => 'utf-8',
524                                  $indexer->add(                                  load_row_coderef => sub {
525                                          id => $input->{name} . "/" . $mfn,                                          my ($database,$input,$mfn) = @_;
526                                          ds => $ds,                                          return $store->load_row(
527                                          type => $config->{$use_indexer}->{type},                                                  database => $database,
528                                  ) if ($indexer && $ds);                                                  input => $input,
529                                                    id => $mfn,
530                                  if ($marc) {                                          );
531                                          my $i = 0;                                  },
532                            );
                                         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++;  
                                         }  
533    
534                                          $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);                          $log->debug("ds = ", sub { dump($ds) }) if ($ds);
535    
536                            $store->save_ds(
537                                    database => $database,
538                                    input => $input_name,
539                                    id => $mfn,
540                                    ds => $ds,
541                            ) if ($ds && !$stats);
542    
543                            $indexer->add(
544                                    id => "${input_name}/${mfn}",
545                                    ds => $ds,
546                                    type => $config->get($indexer_config)->{type},
547                            ) if ($indexer && $ds);
548    
549                            if ($marc) {
550                                    my $i = 0;
551    
552                                    while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {
553                                            $marc->add(
554                                                    id => $mfn . ( $i ? "/$i" : '' ),
555                                                    fields => $fields,
556                                                    leader => WebPAC::Normalize::_get_marc_leader(),
557                                                    row => $row,
558                                            );
559                                            $i++;
560                                  }                                  }
561    
562                                  $total_rows++;                                  $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
563                          }                          }
564                    }
565    
566                          $log->info("statistics of fields usage:\n", $input_db->stats) if ($stats);                  if ($validate) {
567                            my $errors = $validate->report;
568                            if ($errors) {
569                                    $log->info("validation errors:\n$errors\n" );
570                                    print $report_fh "$errors\n" if ($report_fh);
571                            }
572    
573                          # close MARC file                          print $report_fh "\nAll possible subfields/delimiter templates:\n", $validate->delimiters_templates( report => 1, current_input => 1 ), "\n\n";
                         $marc->finish if ($marc);  
574    
575                            # must be last thing that touches $validate for this input
576                            $validate->reset;
577                  }                  }
578    
579                    if ($stats) {
580                            my $s = $input_db->stats;
581                            $log->info("statistics of fields usage:\n$s");
582                            print $report_fh "Statistics of fields usage:\n$s" if ($report_fh);
583                    }
584    
585                    # close MARC file
586                    $marc->finish if ($marc);
587    
588                    # close report
589                    close($report_fh) if ($report_fh);
590          }          }
591    
592          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));          eval { $indexer->finish } if ($indexer && $indexer->can('finish'));
# Line 397  while (my ($database, $db_config) = each Line 598  while (my ($database, $db_config) = each
598                  )                  )
599          );          );
600    
         #  
         # 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}]");  
                         }  
                 }  
         }  
601    
602          # end forked process          # end forked process
603          if ($parallel) {          if ($parallel) {
# Line 429  if ($parallel) { Line 613  if ($parallel) {
613          $log->info("all parallel processes finished");          $log->info("all parallel processes finished");
614  }  }
615    
616  foreach my $link (@links) {  # save new delimiters if needed
617          $log->info("adding link $link->{from} -> $link->{to} [$link->{credit}]");  $validate->save_delimiters_templates if ( $validate );
         $indexer->add_link( %{ $link } );  
 }  
618    
619    #
620    # handle links or merge after indexing
621    #
622    
623    if ($merge) {
624            print $estcmd_fh 'sudo /etc/init.d/hyperestraier start',$/;
625            close($estcmd_fh);
626            chmod 0700, $estcmd_path || $log->warn("can't chmod 0700 $estcmd_path: $!");
627            system $estcmd_path;
628    } else {
629            foreach my $link (@links) {
630                    $log->logdie("coderef in link ", Dumper($link), " is ", ref($link), " and not CODE") unless (ref($link) eq 'CODE');
631                    $link->();
632            }
633    }
Legend:
Removed from v.606  
changed lines
  Added in v.851
  ViewVC Help
Powered by ViewVC 1.1.26