/[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 803 by dpavlin, Fri Mar 2 00:32:21 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.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    
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  ) if ($validate_path);  ) if ($validate_path);
171    
172  my $use_indexer = $config->{use_indexer} || 'hyperestraier';  
173    my $use_indexer = $config->use_indexer;
174    $stats ||= $validate;
175  if ($stats) {  if ($stats) {
176          $log->debug("option --stats disables update of indexing engine...");          $log->debug("disabled indexing for stats collection");
177          $use_indexer = undef;          $use_indexer = undef;
178  } else {  } else {
179          $log->info("using $use_indexer indexing engine...");          $log->info("using $use_indexer indexing engine...");
180  }  }
181    
182  # disable indexing when creating marc  # parse normalize files and create source files for lookup and normalization
183  $use_indexer = undef if ($marc_normalize);  
184    my $parser = new WebPAC::Parser( config => $config );
185    
186  my $total_rows = 0;  my $total_rows = 0;
187  my $start_t = time();  my $start_t = time();
188    
189  my @links;  my @links;
 my $indexer;  
190    
191  if ($parallel) {  if ($parallel) {
192          $log->info("Using $parallel processes for speedup");          $log->info("Using $parallel processes for speedup");
193          Proc::Queue::size($parallel);          Proc::Queue::size($parallel);
194  }  }
195    
196  while (my ($database, $db_config) = each %{ $config->{databases} }) {  sub create_ds_config {
197            my ($db_config, $database, $input, $mfn) = @_;
198            my $c = dclone( $db_config );
199            $c->{_} = $database || $log->logconfess("need database");
200            $c->{_mfn} = $mfn || $log->logconfess("need mfn");
201            $c->{input} = $input || $log->logconfess("need input");
202            return $c;
203    }
204    
205    while (my ($database, $db_config) = each %{ $config->databases }) {
206    
207          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);
208          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 216  while (my ($database, $db_config) = each
216                  }                  }
217          }          }
218    
219          if ($use_indexer) {          my $indexer;
220                  my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");          if ($use_indexer && $parser->have_rules( 'search', $database )) {
221    
222                    my $cfg_name = $use_indexer;
223                    $cfg_name =~ s/\-.*$//;
224    
225                    my $indexer_config = $config->get( $cfg_name ) || $log->logdie("can't find '$cfg_name' part in confguration");
226                  $indexer_config->{database} = $database;                  $indexer_config->{database} = $database;
227                  $indexer_config->{clean} = $clean;                  $indexer_config->{clean} = $clean;
228                  $indexer_config->{label} = $db_config->{name};                  $indexer_config->{label} = $db_config->{name};
229    
230                    # force clean if database has links
231                    $indexer_config->{clean} = 1 if ($db_config->{links});
232    
233                  if ($use_indexer eq 'hyperestraier') {                  if ($use_indexer eq 'hyperestraier') {
234    
235                          # open Hyper Estraier database                          # open Hyper Estraier database
236                          use WebPAC::Output::Estraier '0.10';                          use WebPAC::Output::Estraier '0.10';
237                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );                          $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
238                                    
239                    } elsif ($use_indexer eq 'hyperestraier-native') {
240    
241                            # open Hyper Estraier database
242                            use WebPAC::Output::EstraierNative;
243                            $indexer = new WebPAC::Output::EstraierNative( %{ $indexer_config } );
244    
245                  } elsif ($use_indexer eq 'kinosearch') {                  } elsif ($use_indexer eq 'kinosearch') {
246    
247                          # open KinoSearch                          # open KinoSearch
# Line 203  while (my ($database, $db_config) = each Line 258  while (my ($database, $db_config) = each
258    
259    
260          #          #
261            # store Hyper Estraier links to other databases
262            #
263            if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {
264                    foreach my $link (@{ $db_config->{links} }) {
265                            if ($use_indexer eq 'hyperestraier') {
266                                    if ($merge) {
267                                            print $estcmd_fh 'sudo -u www-data estcmd merge ' . $database . ' ' . $link->{to},$/;
268                                    } else {
269                                            $log->info("saving link $database -> $link->{to} [$link->{credit}]");
270                                            push @links, sub {
271                                                    $log->info("adding link $database -> $link->{to} [$link->{credit}]");
272                                                    $indexer->add_link(
273                                                            from => $database,
274                                                            to => $link->{to},
275                                                            credit => $link->{credit},
276                                                    );
277                                            };
278                                    }
279                            } else {
280                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
281                            }
282                    }
283            }
284            next if ($only_links);
285    
286    
287            #
288          # now WebPAC::Store          # now WebPAC::Store
289          #          #
290          my $abs_path = abs_path($0);          my $abs_path = abs_path($0);
291          $abs_path =~ s#/[^/]*$#/#;          $abs_path =~ s#/[^/]*$#/#;
292    
293          my $db_path = $config->{webpac}->{db_path} . '/' . $database;          my $db_path = $config->webpac('db_path');
294    
295          if ($clean) {          if ($clean) {
296                  $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 299  while (my ($database, $db_config) = each
299                  $log->info("working on database '$database' in $db_path");                  $log->info("working on database '$database' in $db_path");
300          }          }
301    
302          my $db = new WebPAC::Store(          my $store = new WebPAC::Store(
303                  path => $db_path,                  path => $db_path,
                 database => $database,  
304                  debug => $debug,                  debug => $debug,
305          );          );
306    
# Line 237  while (my ($database, $db_config) = each Line 318  while (my ($database, $db_config) = each
318                  $log->info("database $database doesn't have inputs defined");                  $log->info("database $database doesn't have inputs defined");
319          }          }
320    
         my @supported_inputs = keys %{ $config->{webpac}->{inputs} };  
   
321          foreach my $input (@inputs) {          foreach my $input (@inputs) {
322    
323                  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));
324    
325                    next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
326    
327                  my $type = lc($input->{type});                  my $type = lc($input->{type});
328    
329                  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')));
330    
331                  my $lookup;                  my $input_module = $config->webpac('inputs')->{$type};
                 if ($input->{lookup}) {  
                         $lookup = new WebPAC::Lookup(  
                                 lookup_file => $input->{lookup},  
                         );  
                         delete( $input->{lookup} );  
                 }  
332    
333                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my @lookups = $parser->have_lookup_create($database, $input);
334    
335                  $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",
336                          $input->{lookup} ? "lookup '$input->{lookup}'" : ""                          @lookups ? " creating lookups: ".join(", ", @lookups) : ""
337                  );                  );
338    
339                    if ($stats) {
340                            # disable modification of records if --stats is in use
341                            delete($input->{modify_records});
342                            delete($input->{modify_file});
343                    }
344    
345                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
346                          module => $input_module,                          module => $input_module,
347                          encoding => $config->{webpac}->{webpac_encoding},                          encoding => $config->webpac('webpac_encoding'),
348                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
349                          offset => $offset,                          offset => $offset,
                         lookup_coderef => sub {  
                                 my $rec = shift || return;  
                                 $lookup->add( $rec );  
                         },  
350                          recode => $input->{recode},                          recode => $input->{recode},
351                          stats => $stats,                          stats => $stats,
352                          modify_records => $input->{modify_records},                          modify_records => $input->{modify_records},
353                            modify_file => $input->{modify_file},
354                  );                  );
355                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
356    
357                    if (defined( $input->{lookup} )) {
358                            $log->warn("$database/$input_name has depriciated lookup definition, removing it...");
359                            delete( $input->{lookup} );
360                    }
361    
362                    my $lookup_coderef;
363    
364                    if (@lookups) {
365    
366                            my $rules = $parser->lookup_create_rules($database, $input) || $log->logdie("no rules found for $database/$input");
367    
368                            $lookup_coderef = sub {
369                                    my $rec = shift || die "need rec!";
370                                    my $mfn = $rec->{'000'}->[0] || die "need mfn in 000";
371    
372                                    WebPAC::Normalize::data_structure(
373                                            row => $rec,
374                                            rules => $rules,
375                                            config => create_ds_config( $db_config, $database, $input, $mfn ),
376                                    );
377    
378                                    #warn "current lookup: ", dump(WebPAC::Normalize::_get_lookup());
379                            };
380    
381                            WebPAC::Normalize::_set_lookup( undef );
382    
383                            $log->debug("created lookup_coderef using:\n$rules");
384    
385                    };
386    
387                    my $lookup_jar;
388    
389                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
390                          path => $input->{path},                          path => $input->{path},
391                          code_page => $input->{encoding},        # database encoding                          code_page => $input->{encoding},        # database encoding
392                            lookup_coderef => $lookup_coderef,
393                            lookup => $lookup_jar,
394                          %{ $input },                          %{ $input },
395                  );                          load_row => sub {
396                                    my $a = shift;
397                  my @norm_array = ref($input->{normalize}) eq 'ARRAY' ?                                  return $store->load_row(
398                          @{ $input->{normalize} } : ( $input->{normalize} );                                          database => $database,
399                                            input => $input_name,
400                  if ($marc_normalize) {                                          id => $a->{id},
401                          @norm_array = ( {                                  );
402                                  path => $marc_normalize,                          },
403                                  output => $marc_output || 'out/marc/' . $database . '-' . $input->{name} . '.marc',                          save_row => sub {
404                          } );                                  my $a = shift;
405                  }                                  return $store->save_row(
406                                            database => $database,
407                                            input => $input_name,
408                                            id => $a->{id},
409                                            row => $a->{row},
410                                    );
411                            },
412    
413                  foreach my $normalize (@norm_array) {                  );
414    
415                          my $normalize_path = $normalize->{path} || $log->logdie("can't find normalize path in config");                  my $lookup_data = WebPAC::Normalize::_get_lookup();
416    
417                          $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} )) {
418                            $log->debug("created following lookups: ", sub { dump( $lookup_data ) } );
419    
420                          my $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";                          foreach my $key (keys %{ $lookup_data->{$database}->{$input_name} }) {
421                                    $store->save_lookup(
422                                            database => $database,
423                                            input => $input_name,
424                                            key => $key,
425                                            data => $lookup_data->{$database}->{$input_name}->{$key},
426                                    );
427                            }
428                    }
429    
430                          $log->info("Using $normalize_path for normalization...");                  my $report_fh;
431                    if ($stats || $validate) {
432                            my $path = "out/report/${database}-${input_name}.txt";
433                            open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
434    
435                            print $report_fh "Report for database '$database' input '$input_name' records ",
436                                    $offset || 1, "-", $limit || $input->{limit} || $maxmfn, "\n\n";
437                            $log->info("Generating report file $path");
438                    }
439    
440                          my $marc = new WebPAC::Output::MARC(                  my $marc;
441                                  path => $normalize->{output},                  if ($marc_generate && $parser->have_rules( 'marc', $database, $input_name )) {
442                            $marc = new WebPAC::Output::MARC(
443                                    path => "out/marc/${database}-${input_name}.marc",
444                                  lint => $marc_lint,                                  lint => $marc_lint,
445                                  dump => $marc_dump,                                  dump => $marc_dump,
446                          ) if ($normalize->{output});                          );
447                    }
448    
449                          # reset position in database                  my $rules = $parser->normalize_rules($database,$input_name) || $log->logdie("no normalize rules found for $database/$input_name");
450                          $input_db->seek(1);                  $log->debug("parsed normalize rules:\n$rules");
451    
452                          foreach my $pos ( 0 ... $input_db->size ) {                  # reset position in database
453                    $input_db->seek(1);
454    
455                                  my $row = $input_db->fetch || next;                  # generate name of config key for indexer (strip everything after -)
456                    my $indexer_config = $use_indexer;
457                    $indexer_config =~ s/^(\w+)-?.*$/$1/g if ($indexer_config);
458    
459                    my $lookup_hash;
460                    my $depends = $parser->depends($database,$input_name);
461            
462                    if ($depends) {
463                            $log->debug("$database/$input_name depends on: ", dump($depends)) if ($depends);
464                            $log->logdie("parser->depends didn't return HASH") unless (ref($depends) eq 'HASH');
465    
466                            foreach my $db (keys %$depends) {
467                                    foreach my $i (keys %{$depends->{$db}}) {
468                                            foreach my $k (keys %{$depends->{$db}->{$i}}) {
469                                                    my $t = time();
470                                                    $log->debug("loading lookup $db/$i");
471                                                    $lookup_hash->{$db}->{$i}->{$k} = $store->load_lookup(
472                                                            database => $db,
473                                                            input => $i,
474                                                            key => $k,
475                                                    );
476                                                    $log->debug(sprintf("lookup $db/$i took %.2fs", time() - $t));
477                                            }
478                                    }
479                            }
480    
481                                  my $mfn = $row->{'000'}->[0];                          $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
482                    }
483    
                                 if (! $mfn || $mfn !~ m#^\d+$#) {  
                                         $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");  
                                         $mfn = $pos;  
                                         push @{ $row->{'000'} }, $pos;  
                                 }  
484    
485                    foreach my $pos ( 0 ... $input_db->size ) {
486    
487                                  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);  
                                 }  
488    
489                                  my $ds_config = dclone($db_config);                          $total_rows++;
490    
491                                  # default values -> database key                          my $mfn = $row->{'000'}->[0];
                                 $ds_config->{_} = $database;  
492    
493                                  # current mfn                          if (! $mfn || $mfn !~ m#^\d+$#) {
494                                  $ds_config->{_mfn} = $mfn;                                  $log->warn("record $pos doesn't have valid MFN but '$mfn', using $pos");
495                                    $mfn = $pos;
496                                    push @{ $row->{'000'} }, $pos;
497                            }
498    
                                 # attach current input  
                                 $ds_config->{input} = $input;  
499    
500                                  my $ds = WebPAC::Normalize::data_structure(                          if ($validate) {
501                                          row => $row,                                  if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
502                                          rules => $rules,                                          $log->error( "MFN $mfn validation error:\n",
503                                          lookup => $lookup ? $lookup->lookup_hash : undef,                                                  $validate->report_error( $errors )
504                                          config => $ds_config,                                          );
505                                          marc_encoding => 'utf-8',                                  }
506                                  );                                  next;   # validation doesn't create any output
507                            }
508    
509                                  $db->save_ds(                          my $ds = WebPAC::Normalize::data_structure(
510                                          id => $mfn,                                  row => $row,
511                                          ds => $ds,                                  rules => $rules,
512                                          prefix => $input->{name},                                  lookup => $lookup_hash,
513                                  ) if ($ds && !$stats);                                  config => create_ds_config( $db_config, $database, $input, $mfn ),
514                                    marc_encoding => 'utf-8',
515                                  $indexer->add(                                  load_row_coderef => sub {
516                                          id => $input->{name} . "/" . $mfn,                                          my ($database,$input,$mfn) = @_;
517                                          ds => $ds,                                          return $store->load_row(
518                                          type => $config->{$use_indexer}->{type},                                                  database => $database,
519                                  ) if ($indexer && $ds);                                                  input => $input,
520                                                    id => $mfn,
521                                  if ($marc) {                                          );
522                                          my $i = 0;                                  },
523                            );
524                                          while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {  
525                                                  $marc->add(                          $log->debug("ds = ", sub { dump($ds) }) if ($ds);
                                                         id => $mfn . ( $i ? "/$i" : '' ),  
                                                         fields => $fields,  
                                                         leader => WebPAC::Normalize::marc_leader(),  
                                                         row => $row,  
                                                 );  
                                                 $i++;  
                                         }  
526    
527                                          $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);                          $store->save_ds(
528                                    database => $database,
529                                    input => $input_name,
530                                    id => $mfn,
531                                    ds => $ds,
532                            ) if ($ds && !$stats);
533    
534                            $indexer->add(
535                                    id => "${input_name}/${mfn}",
536                                    ds => $ds,
537                                    type => $config->get($indexer_config)->{type},
538                            ) if ($indexer && $ds);
539    
540                            if ($marc) {
541                                    my $i = 0;
542    
543                                    while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {
544                                            $marc->add(
545                                                    id => $mfn . ( $i ? "/$i" : '' ),
546                                                    fields => $fields,
547                                                    leader => WebPAC::Normalize::marc_leader(),
548                                                    row => $row,
549                                            );
550                                            $i++;
551                                  }                                  }
552    
553                                  $total_rows++;                                  $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
554                          }                          }
555                    }
556    
557                          $log->info("statistics of fields usage:\n", $input_db->stats) if ($stats);                  if ($validate) {
558                            my $errors = $validate->report;
559                          # close MARC file                          if ($errors) {
560                          $marc->finish if ($marc);                                  $log->info("validation errors:\n$errors\n" );
561                                    print $report_fh "$errors\n" if ($report_fh);
562                            }
563                    }
564    
565                    if ($stats) {
566                            my $s = $input_db->stats;
567                            $log->info("statistics of fields usage:\n$s");
568                            print $report_fh "Statistics of fields usage:\n$s" if ($report_fh);
569                  }                  }
570    
571                    # close MARC file
572                    $marc->finish if ($marc);
573    
574                    # close report
575                    close($report_fh) if ($report_fh)
576    
577          }          }
578    
579          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 585  while (my ($database, $db_config) = each
585                  )                  )
586          );          );
587    
         #  
         # 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}]");  
                         }  
                 }  
         }  
588    
589          # end forked process          # end forked process
590          if ($parallel) {          if ($parallel) {
# Line 429  if ($parallel) { Line 600  if ($parallel) {
600          $log->info("all parallel processes finished");          $log->info("all parallel processes finished");
601  }  }
602    
603  foreach my $link (@links) {  #
604          $log->info("adding link $link->{from} -> $link->{to} [$link->{credit}]");  # handle links or merge after indexing
605          $indexer->add_link( %{ $link } );  #
606    
607    if ($merge) {
608            print $estcmd_fh 'sudo /etc/init.d/hyperestraier start',$/;
609            close($estcmd_fh);
610            chmod 0700, $estcmd_path || $log->warn("can't chmod 0700 $estcmd_path: $!");
611            system $estcmd_path;
612    } else {
613            foreach my $link (@links) {
614                    $log->logdie("coderef in link ", Dumper($link), " is ", ref($link), " and not CODE") unless (ref($link) eq 'CODE');
615                    $link->();
616            }
617  }  }
   
Legend:
Removed from v.606  
changed lines
  Added in v.803
  ViewVC Help
Powered by ViewVC 1.1.26