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