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