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