/[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 774 by dpavlin, Fri Nov 3 20:56:21 2006 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.06;
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/;
# Line 60  path to YAML configuration file Line 60  path to YAML configuration file
60    
61  =item --stats  =item --stats
62    
63  disable indexing and dump statistics about field and subfield  disable indexing, modify_* in configuration and dump statistics about field
64  usage for each input  and subfield usage for each input
65    
66  =item --validate path/to/validation_file  =item --validate path/to/validation_file
67    
68  turn on extra validation of imput records, see L<WebPAC::Validation>  turn on extra validation of imput records, see L<WebPAC::Validation>
69    
 =item --marc-normalize conf/normalize/mapping.pl  
   
 This option specifies normalisation file for MARC creation  
   
 =item --marc-output out/marc/test.marc  
   
 Optional path to output file  
   
70  =item --marc-lint  =item --marc-lint
71    
72  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
73  messages with C<--no-marc-lint>.  messages with C<--no-marc-lint>.
74    
75  =item --marc-dump  =item --marc-dump
# Line 89  Force dump or input and marc record for Line 81  Force dump or input and marc record for
81  Run databases in parallel (aproximatly same as number of processors in  Run databases in parallel (aproximatly same as number of processors in
82  machine if you want to use full load)  machine if you want to use full load)
83    
84    =item --only-links
85    
86    Create just links
87    
88    =item --merge
89    
90    Create merged index of databases which have links
91    
92  =back  =back
93    
94  =cut  =cut
# Line 97  my $offset; Line 97  my $offset;
97  my $limit;  my $limit;
98    
99  my $clean = 0;  my $clean = 0;
100  my $config = 'conf/config.yml';  my $config_path;
101  my $debug = 0;  my $debug = 0;
102  my $only_filter;  my $only_filter;
103  my $stats = 0;  my $stats = 0;
104  my $validate_path;  my $validate_path;
 my ($marc_normalize, $marc_output);  
105  my $marc_lint = 1;  my $marc_lint = 1;
106  my $marc_dump = 0;  my $marc_dump = 0;
   
107  my $parallel = 0;  my $parallel = 0;
108    my $only_links = 0;
109    my $merge = 0;
110    
111    my $log = _new WebPAC::Common()->_get_logger();
112    
113  GetOptions(  GetOptions(
114          "limit=i" => \$limit,          "limit=i" => \$limit,
# Line 114  GetOptions( Line 116  GetOptions(
116          "clean" => \$clean,          "clean" => \$clean,
117          "one=s" => \$only_filter,          "one=s" => \$only_filter,
118          "only=s" => \$only_filter,          "only=s" => \$only_filter,
119          "config" => \$config,          "config" => \$config_path,
120          "debug+" => \$debug,          "debug+" => \$debug,
121          "stats" => \$stats,          "stats" => \$stats,
122          "validate=s" => \$validate_path,          "validate=s" => \$validate_path,
         "marc-normalize=s" => \$marc_normalize,  
         "marc-output=s" => \$marc_output,  
123          "marc-lint!" => \$marc_lint,          "marc-lint!" => \$marc_lint,
124          "marc-dump!" => \$marc_dump,          "marc-dump!" => \$marc_dump,
125          "parallel=i" => \$parallel,          "parallel=i" => \$parallel,
126            "only-links!" => \$only_links,
127            "merge" => \$merge,
128  );  );
129    
130  $config = LoadFile($config);  my $config = new WebPAC::Config( path => $config_path );
131    
132  print "config = ",dump($config) if ($debug);  #print "config = ",dump($config) if ($debug);
133    
134  die "no databases in config file!\n" unless ($config->{databases});  die "no databases in config file!\n" unless ($config->databases);
135    
 my $log = _new WebPAC::Common()->_get_logger();  
136  $log->info( "-" x 79 );  $log->info( "-" x 79 );
137    
138    
139    my $estcmd_fh;
140    my $estcmd_path = './estcmd-merge.sh';
141    if ($merge) {
142            open($estcmd_fh, '>', $estcmd_path) || $log->logdie("can't open $estcmd_path: $!");
143            print $estcmd_fh 'cd /data/estraier/_node/ || exit 1',$/;
144            print $estcmd_fh 'sudo /etc/init.d/hyperestraier stop',$/;
145            $log->info("created merge batch file $estcmd_path");
146    }
147    
148    
149  my $validate;  my $validate;
150  $validate = new WebPAC::Validate(  $validate = new WebPAC::Validate(
151          path => $validate_path,          path => $validate_path,
152  ) if ($validate_path);  ) if ($validate_path);
153    
154  my $use_indexer = $config->{use_indexer} || 'hyperestraier';  
155    my $use_indexer = $config->use_indexer;
156    $stats ||= $validate;
157  if ($stats) {  if ($stats) {
158          $log->debug("option --stats disables update of indexing engine...");          $log->debug("disabled indexing for stats collection");
159          $use_indexer = undef;          $use_indexer = undef;
160  } else {  } else {
161          $log->info("using $use_indexer indexing engine...");          $log->info("using $use_indexer indexing engine...");
162  }  }
163    
164  # disable indexing when creating marc  # parse normalize files and create source files for lookup and normalization
165  $use_indexer = undef if ($marc_normalize);  
166    my $parser = new WebPAC::Parser( config => $config );
167    
168  my $total_rows = 0;  my $total_rows = 0;
169  my $start_t = time();  my $start_t = time();
170    
171  my @links;  my @links;
 my $indexer;  
172    
173  if ($parallel) {  if ($parallel) {
174          $log->info("Using $parallel processes for speedup");          $log->info("Using $parallel processes for speedup");
175          Proc::Queue::size($parallel);          Proc::Queue::size($parallel);
176  }  }
177    
178  while (my ($database, $db_config) = each %{ $config->{databases} }) {  sub create_ds_config {
179            my ($db_config, $database, $input, $mfn) = @_;
180            my $c = dclone( $db_config );
181            $c->{_} = $database || $log->logconfess("need database");
182            $c->{_mfn} = $mfn || $log->logconfess("need mfn");
183            $c->{input} = $input || $log->logconfess("need input");
184            return $c;
185    }
186    
187    while (my ($database, $db_config) = each %{ $config->databases }) {
188    
189          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);
190          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 198  while (my ($database, $db_config) = each
198                  }                  }
199          }          }
200    
201          if ($use_indexer) {          my $indexer;
202                  my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");          if ($use_indexer && $parser->have_rules( 'search', $database )) {
203    
204                    my $cfg_name = $use_indexer;
205                    $cfg_name =~ s/\-.*$//;
206    
207                    my $indexer_config = $config->get( $cfg_name ) || $log->logdie("can't find '$cfg_name' part in confguration");
208                  $indexer_config->{database} = $database;                  $indexer_config->{database} = $database;
209                  $indexer_config->{clean} = $clean;                  $indexer_config->{clean} = $clean;
210                  $indexer_config->{label} = $db_config->{name};                  $indexer_config->{label} = $db_config->{name};
211    
212                    # force clean if database has links
213                    $indexer_config->{clean} = 1 if ($db_config->{links});
214    
215                  if ($use_indexer eq 'hyperestraier') {                  if ($use_indexer eq 'hyperestraier') {
216    
217                          # open Hyper Estraier database                          # open Hyper Estraier database
218                          use WebPAC::Output::Estraier '0.10';                          use WebPAC::Output::Estraier '0.10';
219                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
220                                    
221                    } elsif ($use_indexer eq 'hyperestraier-native') {
222    
223                            # open Hyper Estraier database
224                            use WebPAC::Output::EstraierNative;
225                            $indexer = new WebPAC::Output::EstraierNative( %{ $indexer_config } );
226    
227                  } elsif ($use_indexer eq 'kinosearch') {                  } elsif ($use_indexer eq 'kinosearch') {
228    
229                          # open KinoSearch                          # open KinoSearch
# Line 203  while (my ($database, $db_config) = each Line 240  while (my ($database, $db_config) = each
240    
241    
242          #          #
243            # store Hyper Estraier links to other databases
244            #
245            if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {
246                    foreach my $link (@{ $db_config->{links} }) {
247                            if ($use_indexer eq 'hyperestraier') {
248                                    if ($merge) {
249                                            print $estcmd_fh 'sudo -u www-data estcmd merge ' . $database . ' ' . $link->{to},$/;
250                                    } else {
251                                            $log->info("saving link $database -> $link->{to} [$link->{credit}]");
252                                            push @links, sub {
253                                                    $log->info("adding link $database -> $link->{to} [$link->{credit}]");
254                                                    $indexer->add_link(
255                                                            from => $database,
256                                                            to => $link->{to},
257                                                            credit => $link->{credit},
258                                                    );
259                                            };
260                                    }
261                            } else {
262                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
263                            }
264                    }
265            }
266            next if ($only_links);
267    
268    
269            #
270          # now WebPAC::Store          # now WebPAC::Store
271          #          #
272          my $abs_path = abs_path($0);          my $abs_path = abs_path($0);
273          $abs_path =~ s#/[^/]*$#/#;          $abs_path =~ s#/[^/]*$#/#;
274    
275          my $db_path = $config->{webpac}->{db_path} . '/' . $database;          my $db_path = $config->webpac('db_path');
276    
277          if ($clean) {          if ($clean) {
278                  $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 281  while (my ($database, $db_config) = each
281                  $log->info("working on database '$database' in $db_path");                  $log->info("working on database '$database' in $db_path");
282          }          }
283    
284          my $db = new WebPAC::Store(          my $store = new WebPAC::Store(
285                  path => $db_path,                  path => $db_path,
                 database => $database,  
286                  debug => $debug,                  debug => $debug,
287          );          );
288    
# Line 237  while (my ($database, $db_config) = each Line 300  while (my ($database, $db_config) = each
300                  $log->info("database $database doesn't have inputs defined");                  $log->info("database $database doesn't have inputs defined");
301          }          }
302    
         my @supported_inputs = keys %{ $config->{webpac}->{inputs} };  
   
303          foreach my $input (@inputs) {          foreach my $input (@inputs) {
304    
305                  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));
306    
307                    next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
308    
309                  my $type = lc($input->{type});                  my $type = lc($input->{type});
310    
311                  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')));
312    
313                  my $lookup;                  my $input_module = $config->webpac('inputs')->{$type};
                 if ($input->{lookup}) {  
                         $lookup = new WebPAC::Lookup(  
                                 lookup_file => $input->{lookup},  
                         );  
                         delete( $input->{lookup} );  
                 }  
314    
315                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my @lookups = $parser->have_lookup_create($database, $input);
316    
317                  $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",
318                          $input->{lookup} ? "lookup '$input->{lookup}'" : ""                          @lookups ? " creating lookups: ".join(", ", @lookups) : ""
319                  );                  );
320    
321                    if ($stats) {
322                            # disable modification of records if --stats is in use
323                            delete($input->{modify_records});
324                            delete($input->{modify_file});
325                    }
326    
327                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
328                          module => $input_module,                          module => $input_module,
329                          encoding => $config->{webpac}->{webpac_encoding},                          encoding => $config->webpac('webpac_encoding'),
330                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
331                          offset => $offset,                          offset => $offset,
                         lookup_coderef => sub {  
                                 my $rec = shift || return;  
                                 $lookup->add( $rec );  
                         },  
332                          recode => $input->{recode},                          recode => $input->{recode},
333                          stats => $stats,                          stats => $stats,
334                          modify_records => $input->{modify_records},                          modify_records => $input->{modify_records},
335                            modify_file => $input->{modify_file},
336                  );                  );
337                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
338    
339                    if (defined( $input->{lookup} )) {
340                            $log->warn("$database/$input_name has depriciated lookup definition, removing it...");
341                            delete( $input->{lookup} );
342                    }
343    
344                    my $lookup_coderef;
345    
346                    if (@lookups) {
347    
348                            my $rules = $parser->lookup_create_rules($database, $input) || $log->logdie("no rules found for $database/$input");
349    
350                            $lookup_coderef = sub {
351                                    my $rec = shift || die "need rec!";
352                                    my $mfn = $rec->{'000'}->[0] || die "need mfn in 000";
353    
354                                    WebPAC::Normalize::data_structure(
355                                            row => $rec,
356                                            rules => $rules,
357                                            config => create_ds_config( $db_config, $database, $input, $mfn ),
358                                    );
359    
360                                    #warn "current lookup: ", dump(WebPAC::Normalize::_get_lookup());
361                            };
362    
363                            WebPAC::Normalize::_set_lookup( undef );
364    
365                            $log->debug("created lookup_coderef using:\n$rules");
366    
367                    };
368    
369                    my $lookup_jar;
370    
371                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
372                          path => $input->{path},                          path => $input->{path},
373                          code_page => $input->{encoding},        # database encoding                          code_page => $input->{encoding},        # database encoding
374                            lookup_coderef => $lookup_coderef,
375                            lookup => $lookup_jar,
376                          %{ $input },                          %{ $input },
377                  );                          load_row => sub {
378                                    my $a = shift;
379                  my @norm_array = ref($input->{normalize}) eq 'ARRAY' ?                                  return $store->load_row(
380                          @{ $input->{normalize} } : ( $input->{normalize} );                                          database => $database,
381                                            input => $input_name,
382                  if ($marc_normalize) {                                          id => $a->{id},
383                          @norm_array = ( {                                  );
384                                  path => $marc_normalize,                          },
385                                  output => $marc_output || 'out/marc/' . $database . '-' . $input->{name} . '.marc',                          save_row => sub {
386                          } );                                  my $a = shift;
387                  }                                  return $store->save_row(
388                                            database => $database,
389                                            input => $input_name,
390                                            id => $a->{id},
391                                            row => $a->{row},
392                                    );
393                            },
394    
395                  foreach my $normalize (@norm_array) {                  );
396    
397                          my $normalize_path = $normalize->{path} || $log->logdie("can't find normalize path in config");                  my $lookup_data = WebPAC::Normalize::_get_lookup();
398    
399                          $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} )) {
400                            $log->debug("created following lookups: ", sub { dump( $lookup_data ) } );
401    
402                          my $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";                          foreach my $key (keys %{ $lookup_data->{$database}->{$input_name} }) {
403                                    $store->save_lookup(
404                                            database => $database,
405                                            input => $input_name,
406                                            key => $key,
407                                            data => $lookup_data->{$database}->{$input_name}->{$key},
408                                    );
409                            }
410                    }
411    
412                          $log->info("Using $normalize_path for normalization...");                  my $report_fh;
413                    if ($stats || $validate) {
414                            my $path = "out/report/${database}-${input_name}.txt";
415                            open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
416    
417                            print $report_fh "Report for database '$database' input '$input_name' records ",
418                                    $offset || 1, "-", $limit || $input->{limit} || $maxmfn, "\n\n";
419                            $log->info("Generating report file $path");
420                    }
421    
422                          my $marc = new WebPAC::Output::MARC(                  my $marc;
423                                  path => $normalize->{output},                  if ($parser->have_rules( 'marc', $database, $input_name )) {
424                            $marc = new WebPAC::Output::MARC(
425                                    path => "out/marc/${database}-${input_name}.marc",
426                                  lint => $marc_lint,                                  lint => $marc_lint,
427                                  dump => $marc_dump,                                  dump => $marc_dump,
428                          ) if ($normalize->{output});                          );
429                    }
430    
431                          # reset position in database                  my $rules = $parser->normalize_rules($database,$input_name) || $log->logdie("no normalize rules found for $database/$input_name");
432                          $input_db->seek(1);                  $log->debug("parsed normalize rules:\n$rules");
433    
434                          foreach my $pos ( 0 ... $input_db->size ) {                  # reset position in database
435                    $input_db->seek(1);
436    
437                                  my $row = $input_db->fetch || next;                  # generate name of config key for indexer (strip everything after -)
438                    my $indexer_config = $use_indexer;
439                    $indexer_config =~ s/^(\w+)-?.*$/$1/g if ($indexer_config);
440    
441                    my $lookup_hash;
442                    my $depends = $parser->depends($database,$input_name);
443            
444                    if ($depends) {
445                            $log->debug("$database/$input_name depends on: ", dump($depends)) if ($depends);
446                            $log->logdie("parser->depends didn't return HASH") unless (ref($depends) eq 'HASH');
447    
448                            foreach my $db (keys %$depends) {
449                                    foreach my $i (keys %{$depends->{$db}}) {
450                                            foreach my $k (keys %{$depends->{$db}->{$i}}) {
451                                                    my $t = time();
452                                                    $log->debug("loading lookup $db/$i");
453                                                    $lookup_hash->{$db}->{$i}->{$k} = $store->load_lookup(
454                                                            database => $db,
455                                                            input => $i,
456                                                            key => $k,
457                                                    );
458                                                    $log->debug(sprintf("lookup $db/$i took %.2fs", time() - $t));
459                                            }
460                                    }
461                            }
462    
463                                  my $mfn = $row->{'000'}->[0];                          $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
464                    }
465    
                                 if (! $mfn || $mfn !~ m#^\d+$#) {  
                                         $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");  
                                         $mfn = $pos;  
                                         push @{ $row->{'000'} }, $pos;  
                                 }  
466    
467                    foreach my $pos ( 0 ... $input_db->size ) {
468    
469                                  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);  
                                 }  
470    
471                                  my $ds_config = dclone($db_config);                          $total_rows++;
472    
473                                  # default values -> database key                          my $mfn = $row->{'000'}->[0];
                                 $ds_config->{_} = $database;  
474    
475                                  # current mfn                          if (! $mfn || $mfn !~ m#^\d+$#) {
476                                  $ds_config->{_mfn} = $mfn;                                  $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");
477                                    $mfn = $pos;
478                                    push @{ $row->{'000'} }, $pos;
479                            }
480    
                                 # attach current input  
                                 $ds_config->{input} = $input;  
481    
482                                  my $ds = WebPAC::Normalize::data_structure(                          if ($validate) {
483                                          row => $row,                                  if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
484                                          rules => $rules,                                          $log->error( "MFN $mfn validation error:\n",
485                                          lookup => $lookup ? $lookup->lookup_hash : undef,                                                  $validate->report_error( $errors )
486                                          config => $ds_config,                                          );
487                                          marc_encoding => 'utf-8',                                  }
488                                  );                                  next;   # validation doesn't create any output
489                            }
490    
491                                  $db->save_ds(                          my $ds = WebPAC::Normalize::data_structure(
492                                          id => $mfn,                                  row => $row,
493                                          ds => $ds,                                  rules => $rules,
494                                          prefix => $input->{name},                                  lookup => $lookup_hash,
495                                  ) if ($ds && !$stats);                                  config => create_ds_config( $db_config, $database, $input, $mfn ),
496                                    marc_encoding => 'utf-8',
497                                  $indexer->add(                                  load_row_coderef => sub {
498                                          id => $input->{name} . "/" . $mfn,                                          my ($database,$input,$mfn) = @_;
499                                          ds => $ds,                                          return $store->load_row(
500                                          type => $config->{$use_indexer}->{type},                                                  database => $database,
501                                  ) if ($indexer && $ds);                                                  input => $input,
502                                                    id => $mfn,
503                                  if ($marc) {                                          );
504                                          my $i = 0;                                  },
505                            );
506                                          while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {  
507                                                  $marc->add(                          $log->debug("ds = ", sub { dump($ds) }) if ($ds);
                                                         id => $mfn . ( $i ? "/$i" : '' ),  
                                                         fields => $fields,  
                                                         leader => WebPAC::Normalize::marc_leader(),  
                                                         row => $row,  
                                                 );  
                                                 $i++;  
                                         }  
508    
509                                          $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);                          $store->save_ds(
510                                    database => $database,
511                                    input => $input_name,
512                                    id => $mfn,
513                                    ds => $ds,
514                            ) if ($ds && !$stats);
515    
516                            $indexer->add(
517                                    id => "${input_name}/${mfn}",
518                                    ds => $ds,
519                                    type => $config->get($indexer_config)->{type},
520                            ) if ($indexer && $ds);
521    
522                            if ($marc) {
523                                    my $i = 0;
524    
525                                    while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {
526                                            $marc->add(
527                                                    id => $mfn . ( $i ? "/$i" : '' ),
528                                                    fields => $fields,
529                                                    leader => WebPAC::Normalize::marc_leader(),
530                                                    row => $row,
531                                            );
532                                            $i++;
533                                  }                                  }
534    
535                                  $total_rows++;                                  $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
536                          }                          }
537                    }
538    
539                          $log->info("statistics of fields usage:\n", $input_db->stats) if ($stats);                  if ($validate) {
540                            my $errors = $validate->report;
541                          # close MARC file                          if ($errors) {
542                          $marc->finish if ($marc);                                  $log->info("validation errors:\n$errors\n" );
543                                    print $report_fh "$errors\n" if ($report_fh);
544                            }
545                    }
546    
547                    if ($stats) {
548                            my $s = $input_db->stats;
549                            $log->info("statistics of fields usage:\n$s");
550                            print $report_fh "Statistics of fields usage:\n$s" if ($report_fh);
551                  }                  }
552    
553                    # close MARC file
554                    $marc->finish if ($marc);
555    
556                    # close report
557                    close($report_fh) if ($report_fh)
558    
559          }          }
560    
561          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 567  while (my ($database, $db_config) = each
567                  )                  )
568          );          );
569    
         #  
         # 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}]");  
                         }  
                 }  
         }  
570    
571          # end forked process          # end forked process
572          if ($parallel) {          if ($parallel) {
# Line 429  if ($parallel) { Line 582  if ($parallel) {
582          $log->info("all parallel processes finished");          $log->info("all parallel processes finished");
583  }  }
584    
585  foreach my $link (@links) {  #
586          $log->info("adding link $link->{from} -> $link->{to} [$link->{credit}]");  # handle links or merge after indexing
587          $indexer->add_link( %{ $link } );  #
588    
589    if ($merge) {
590            print $estcmd_fh 'sudo /etc/init.d/hyperestraier start',$/;
591            close($estcmd_fh);
592            chmod 0700, $estcmd_path || $log->warn("can't chmod 0700 $estcmd_path: $!");
593            system $estcmd_path;
594    } else {
595            foreach my $link (@links) {
596                    $log->logdie("coderef in link ", Dumper($link), " is ", ref($link), " and not CODE") unless (ref($link) eq 'CODE');
597                    $link->();
598            }
599  }  }
   
Legend:
Removed from v.606  
changed lines
  Added in v.774
  ViewVC Help
Powered by ViewVC 1.1.26