/[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 493 by dpavlin, Sun May 14 13:42:48 2006 UTC revision 868 by dpavlin, Thu Jun 21 21:26:17 2007 UTC
# Line 4  use strict; Line 4  use strict;
4    
5  use Cwd qw/abs_path/;  use Cwd qw/abs_path/;
6  use File::Temp qw/tempdir/;  use File::Temp qw/tempdir/;
 use Data::Dumper;  
7  use lib './lib';  use lib './lib';
8    
9  use WebPAC::Common 0.02;  use WebPAC::Common 0.02;
10  use WebPAC::Lookup;  use WebPAC::Parser 0.08;
11  use WebPAC::Input 0.03;  use WebPAC::Input 0.16;
12  use WebPAC::Store 0.03;  use WebPAC::Store 0.14;
13  use WebPAC::Normalize::XML;  use WebPAC::Normalize 0.22;
 use WebPAC::Normalize::Set;  
14  use WebPAC::Output::TT;  use WebPAC::Output::TT;
15  use YAML qw/LoadFile/;  use WebPAC::Validate 0.11;
16    use WebPAC::Output::MARC;
17    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/;
23    use Storable qw/dclone/;
24    use Pod::Usage qw/pod2usage/;
25    
26    use Proc::Queue size => 1;
27    use POSIX ":sys_wait_h"; # imports WNOHANG
28    
29  =head1 NAME  =head1 NAME
30    
# Line 26  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 42  limit loading to 100 records Line 48  limit loading to 100 records
48    
49  remove database and Hyper Estraier index before indexing  remove database and Hyper Estraier index before indexing
50    
51  =item --only=database_name  =item --only=database_name/input_filter
52    
53  reindex just single database (legacy name is --one)  reindex just single database (legacy name is --one)
54    
55    C</input_filter> is optional part which can be C<name>
56    or C<type> from input
57    
58  =item --config conf/config.yml  =item --config conf/config.yml
59    
60  path to YAML configuration file  path to YAML configuration file
61    
62  =item --force-set  =item --stats
63    
64    disable indexing, modify_* in configuration and dump statistics about field
65    and subfield usage for each input
66    
67    =item --validate path/to/validation_file
68    
69    turn on extra validation of imput records, see L<WebPAC::Validation>
70    
71    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    =item --validate-delimiters path/to/validate_delimiters_file
75    
76    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    =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
85    
86    By default turned on if normalisation file has C<marc*> directives. You can disable lint
87    messages with C<--no-marc-lint>.
88    
89    =item --marc-dump
90    
91    Force dump or input and marc record for debugging.
92    
93    =item --parallel 4
94    
95    Run databases in parallel (aproximatly same as number of processors in
96    machine if you want to use full load)
97    
98    =item --only-links
99    
100    Create just links
101    
102  force conversion C<normalize->path> in C<config.yml> from  =item --merge
103  C<.xml> to C<.pl>  
104    Create merged index of databases which have links
105    
106  =back  =back
107    
# Line 63  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_db_name;  my $only_filter;
117  my $force_set = 0;  my $stats = 0;
118    my $validate_path;
119    my $validate_delimiters_path;
120    my $marc_generate = 1;
121    my $marc_lint = 1;
122    my $marc_dump = 0;
123    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,
132          "offset=i" => \$offset,          "offset=i" => \$offset,
133          "clean" => \$clean,          "clean" => \$clean,
134          "one=s" => \$only_db_name,          "one=s" => \$only_filter,
135          "only=s" => \$only_db_name,          "only=s" => \$only_filter,
136          "config" => \$config,          "config" => \$config_path,
137          "debug" => \$debug,          "debug+" => \$debug,
138          "force-set" => \$force_set,          "stats" => \$stats,
139            "validate=s" => \$validate_path,
140            "validate-delimiters=s" => \$validate_delimiters_path,
141            "marc-generate!" => \$marc_generate,
142            "marc-lint!" => \$marc_lint,
143            "marc-dump!" => \$marc_dump,
144            "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 = ",Dumper($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  my $log = _new WebPAC::Common()->_get_logger();  #print "config = ",dump($config) if ($debug);
157    
158    die "no databases in config file!\n" unless ($config->databases);
159    
160    $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 $use_indexer = $config->{use_indexer} || 'hyperestraier';  my $estcmd_fh;
170  $log->info("using $use_indexer indexing engine...");  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;
179    $validate = new WebPAC::Validate(
180            delimiters => $config->webpac('delimiters'),
181    ) if ($validate_path || $validate_delimiters_path);
182    
183    my $use_indexer = $config->use_indexer;
184    $stats ||= $validate;
185    if ($stats) {
186            $log->debug("disabled indexing for stats collection");
187            $use_indexer = undef;
188    } elsif ( $use_indexer ) {
189            $log->info("using $use_indexer indexing engine...");
190    }
191    
192    # parse normalize files and create source files for lookup and normalization
193    
194    my $parser = new WebPAC::Parser( config => $config );
195    
196  my $total_rows = 0;  my $total_rows = 0;
197  my $start_t = time();  my $start_t = time();
198    
199  while (my ($database, $db_config) = each %{ $config->{databases} }) {  my @links;
200    
201    if ($parallel) {
202            $log->info("Using $parallel processes for speedup");
203            Proc::Queue::size($parallel);
204    }
205    
206    sub create_ds_config {
207            my ($db_config, $database, $input, $mfn) = @_;
208            my $c = dclone( $db_config );
209            $c->{_} = $database || $log->logconfess("need database");
210            $c->{_mfn} = $mfn || $log->logconfess("need mfn");
211            $c->{input} = $input || $log->logconfess("need input");
212            return $c;
213    }
214    
215          next if ($only_db_name && $database !~ m/$only_db_name/i);  foreach my $database ( sort keys %{ $config->databases } ) {
216            my $db_config = $config->databases->{$database};
217    
218            my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);
219            next if ($only_database && $database !~ m/$only_database/i);
220    
221            if ($parallel) {
222                    my $f=fork;
223                    if(defined ($f) and $f==0) {
224                            $log->info("Created processes $$ for speedup");
225                    } else {
226                            next;
227                    }
228            }
229    
230          my $indexer;          my $indexer;
231            if ($use_indexer && $parser->have_rules( 'search', $database )) {
232    
233          my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");                  my $cfg_name = $use_indexer;
234          $indexer_config->{database} = $database;                  $cfg_name =~ s/\-.*$//;
         $indexer_config->{clean} = $clean;  
         $indexer_config->{label} = $db_config->{name};  
   
         # important: clean database just once!  
         $clean = 0;  
   
         if ($use_indexer eq 'hyperestraier') {  
   
                 # open Hyper Estraier database  
                 use WebPAC::Output::Estraier '0.10';  
                 $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );  
           
         } elsif ($use_indexer eq 'kinosearch') {  
235    
236                  # open KinoSearch                  my $indexer_config = $config->get( $cfg_name ) || $log->logdie("can't find '$cfg_name' part in confguration");
237                  use WebPAC::Output::KinoSearch;                  $indexer_config->{database} = $database;
238                  $indexer_config->{clean} = 1 unless (-e $indexer_config->{index_path});                  $indexer_config->{clean} = $clean;
239                  $indexer = new WebPAC::Output::KinoSearch( %{ $indexer_config } );                  $indexer_config->{label} = $db_config->{name};
240    
241          } else {                  # force clean if database has links
242                  $log->logdie("unknown use_indexer: $use_indexer");                  $indexer_config->{clean} = 1 if ($db_config->{links});
243    
244                    if ($use_indexer eq 'hyperestraier') {
245    
246                            # open Hyper Estraier database
247                            require WebPAC::Output::Estraier;
248                            $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
249                    
250                    } elsif ($use_indexer eq 'hyperestraier-native') {
251    
252                            # open Hyper Estraier database
253                            require WebPAC::Output::EstraierNative;
254                            $indexer = new WebPAC::Output::EstraierNative( %{ $indexer_config } );
255    
256                    } elsif ($use_indexer eq 'kinosearch') {
257    
258                            # open KinoSearch
259                            require WebPAC::Output::KinoSearch;
260                            $indexer_config->{clean} = 1 unless (-e $indexer_config->{index_path});
261                            $indexer = new WebPAC::Output::KinoSearch( %{ $indexer_config } );
262    
263                    } else {
264                            $log->logdie("unknown use_indexer: $use_indexer");
265                    }
266    
267                    $log->logdie("can't continue without valid indexer") unless ($indexer);
268          }          }
269    
270          $log->logide("can't continue without valid indexer") unless ($indexer);  
271            #
272            # store Hyper Estraier links to other databases
273            #
274            if (ref($db_config->{links}) eq 'ARRAY' && $use_indexer) {
275                    foreach my $link (@{ $db_config->{links} }) {
276                            if ($use_indexer eq 'hyperestraier') {
277                                    if ($merge) {
278                                            print $estcmd_fh 'sudo -u www-data estcmd merge ' . $database . ' ' . $link->{to},$/;
279                                    } else {
280                                            $log->info("saving link $database -> $link->{to} [$link->{credit}]");
281                                            push @links, sub {
282                                                    $log->info("adding link $database -> $link->{to} [$link->{credit}]");
283                                                    $indexer->add_link(
284                                                            from => $database,
285                                                            to => $link->{to},
286                                                            credit => $link->{credit},
287                                                    );
288                                            };
289                                    }
290                            } else {
291                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
292                            }
293                    }
294            }
295            next if ($only_links);
296    
297    
298          #          #
299          # now WebPAC::Store          # now WebPAC::Store
# Line 132  while (my ($database, $db_config) = each Line 301  while (my ($database, $db_config) = each
301          my $abs_path = abs_path($0);          my $abs_path = abs_path($0);
302          $abs_path =~ s#/[^/]*$#/#;          $abs_path =~ s#/[^/]*$#/#;
303    
304          my $db_path = $config->{webpac}->{db_path} . '/' . $database;          my $db_path = $config->webpac('db_path');
305    
306          if ($clean) {          if ($clean) {
307                  $log->info("creating new database $database in $db_path");                  $log->info("creating new database '$database' in $db_path");
308                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");
309          } else {          } else {
310                  $log->debug("working on $database in $db_path");                  $log->info("working on database '$database' in $db_path");
311          }          }
312    
313          my $db = new WebPAC::Store(          my $store = new WebPAC::Store(
314                  path => $db_path,                  path => $db_path,
                 database => $database,  
315                  debug => $debug,                  debug => $debug,
316          );          );
317    
# Line 161  while (my ($database, $db_config) = each Line 329  while (my ($database, $db_config) = each
329                  $log->info("database $database doesn't have inputs defined");                  $log->info("database $database doesn't have inputs defined");
330          }          }
331    
         my @supported_inputs = keys %{ $config->{webpac}->{inputs} };  
   
332          foreach my $input (@inputs) {          foreach my $input (@inputs) {
333    
334                    my $input_name = $input->{name} || $log->logdie("input without a name isn't valid: ",dump($input));
335    
336                    next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
337    
338                  my $type = lc($input->{type});                  my $type = lc($input->{type});
339    
340                  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')));
341    
342                  my $lookup = new WebPAC::Lookup(                  my $input_module = $config->webpac('inputs')->{$type};
                         lookup_file => $input->{lookup},  
                 );  
343    
344                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my @lookups = $parser->have_lookup_create($database, $input);
345    
346                    $log->info("working on input '$input_name' in $input->{path} [type: $input->{type}] using $input_module",
347                            @lookups ? " creating lookups: ".join(", ", @lookups) : ""
348                    );
349    
350                  $log->info("working on input '$input->{path}' [$input->{type}] using $input_module lookup '$input->{lookup}'");                  if ($stats) {
351                            # disable modification of records if --stats is in use
352                            delete($input->{modify_records});
353                            delete($input->{modify_file});
354                    }
355    
356                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
357                          module => $input_module,                          module => $input_module,
358                          code_page => $config->{webpac}->{webpac_encoding},                          encoding => $config->webpac('webpac_encoding'),
359                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
360                          offset => $offset,                          offset => $offset,
                         lookup => $lookup,  
361                          recode => $input->{recode},                          recode => $input->{recode},
362                            stats => $stats,
363                            modify_records => $input->{modify_records},
364                            modify_file => $input->{modify_file},
365                            input_config => $input,
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 },
407                            load_row => sub {
408                                    my $a = shift;
409                                    return $store->load_row(
410                                            database => $database,
411                                            input => $input_name,
412                                            id => $a->{id},
413                                    );
414                            },
415                            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    
                 my $n = new WebPAC::Normalize::XML(  
                 #       filter => { 'foo' => sub { shift } },  
                         db => $db,  
                         lookup_regex => $lookup->regex,  
                         lookup => $lookup,  
                         prefix => $input->{name},  
425                  );                  );
426    
427                  my $rules;                  my $lookup_data = WebPAC::Normalize::_get_lookup();
                 my $normalize_path = $input->{normalize}->{path};  
428    
429                  if ($force_set) {                  if (defined( $lookup_data->{$database}->{$input_name} )) {
430                          my $new_norm_path = $normalize_path;                          $log->debug("created following lookups: ", sub { dump( $lookup_data ) } );
431                          $new_norm_path =~ s/\.xml$/.pl/;  
432                          if (-e $new_norm_path) {                          foreach my $key (keys %{ $lookup_data->{$database}->{$input_name} }) {
433                                  $log->debug("--force-set replaced $normalize_path with $new_norm_path");                                  $store->save_lookup(
434                                  $normalize_path = $new_norm_path;                                          database => $database,
435                          } else {                                          input => $input_name,
436                                  $log->debug("--force-set failed on $new_norm_path, fallback to $normalize_path");                                          key => $key,
437                                            data => $lookup_data->{$database}->{$input_name}->{$key},
438                                    );
439                          }                          }
440                  }                  }
441    
442                  if ($normalize_path =~ m/\.xml$/i) {                  my $report_fh;
443                          $n->open(                  if ($stats || $validate) {
444                                  tag => $input->{normalize}->{tag},                          my $path = "out/report/${database}-${input_name}.txt";
445                                  xml_file => $normalize_path,                          open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
446                          );  
447                  } elsif ($normalize_path =~ m/\.(?:yml|yaml)$/i) {                          print $report_fh "Report for database '$database' input '$input_name' records ",
448                          $n->open_yaml(                                  $offset || 1, "-", $limit || $input->{limit} || $maxmfn, "\n\n";
449                                  path => $normalize_path,                          $log->info("Generating report file $path");
450                                  tag => $input->{normalize}->{tag},  
451                            if ( $validate ) {
452                                    $validate->read_validate_file( $validate->fill_in( $validate_path, database => $database, input => $input_name ) ) if ( $validate_path );
453                                    $validate->read_validate_delimiters_file( $validate->fill_in( $validate_delimiters_path, database => $database, input => $input_name ) ) if ( $validate_delimiters_path );
454                            }
455                    }
456    
457                    my $marc;
458                    if ($marc_generate && $parser->have_rules( 'marc', $database, $input_name )) {
459                            $marc = new WebPAC::Output::MARC(
460                                    path => "out/marc/${database}-${input_name}.marc",
461                                    lint => $marc_lint,
462                                    dump => $marc_dump,
463                          );                          );
                 } elsif ($normalize_path =~ m/\.(?:pl)$/i) {  
                         $n = undef;  
                         $log->info("using WebPAC::Normalize::Set to process $normalize_path");  
                         $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";  
464                  }                  }
465    
466                    my $rules = $parser->normalize_rules($database,$input_name) || $log->logdie("no normalize rules found for $database/$input_name");
467                    $log->debug("parsed normalize rules:\n$rules");
468    
469                    # reset position in database
470                    $input_db->seek(1);
471    
472                    # generate name of config key for indexer (strip everything after -)
473                    my $indexer_config = $use_indexer;
474                    $indexer_config =~ s/^(\w+)-?.*$/$1/g if ($indexer_config);
475    
476                    my $lookup_hash;
477                    my $depends = $parser->depends($database,$input_name);
478            
479                    if ($depends) {
480                            $log->debug("$database/$input_name depends on: ", dump($depends)) if ($depends);
481                            $log->logdie("parser->depends didn't return HASH") unless (ref($depends) eq 'HASH');
482    
483                            foreach my $db (keys %$depends) {
484                                    foreach my $i (keys %{$depends->{$db}}) {
485                                            foreach my $k (keys %{$depends->{$db}->{$i}}) {
486                                                    my $t = time();
487                                                    $log->debug("loading lookup $db/$i");
488                                                    $lookup_hash->{$db}->{$i}->{$k} = $store->load_lookup(
489                                                            database => $db,
490                                                            input => $i,
491                                                            key => $k,
492                                                    );
493                                                    $log->debug(sprintf("lookup $db/$i took %.2fs", time() - $t));
494                                            }
495                                    }
496                            }
497    
498                            $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
499                    }
500    
501    
502                  foreach my $pos ( 0 ... $input_db->size ) {                  foreach my $pos ( 0 ... $input_db->size ) {
503    
504                          my $row = $input_db->fetch || next;                          my $row = $input_db->fetch || next;
505    
506                            $total_rows++;
507    
508                          my $mfn = $row->{'000'}->[0];                          my $mfn = $row->{'000'}->[0];
509    
510                          if (! $mfn || $mfn !~ m#^\d+$#) {                          if (! $mfn || $mfn !~ m#^\d+$#) {
# Line 242  while (my ($database, $db_config) = each Line 513  while (my ($database, $db_config) = each
513                                  push @{ $row->{'000'} }, $pos;                                  push @{ $row->{'000'} }, $pos;
514                          }                          }
515    
516                          my $ds = $n ? $n->data_structure($row) :  
517                                  WebPAC::Normalize::Set::data_structure(                          if ($validate) {
518                                          row => $row,                                  if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
519                                          rules => $rules,                                          $log->error( "MFN $mfn validation error:\n",
520                                          lookup => $lookup->lookup_hash,                                                  $validate->report_error( $errors )
521                                  );                                          );
522                                    }
523                                    next;   # validation doesn't create any output
524                            }
525    
526                            my $ds = WebPAC::Normalize::data_structure(
527                                    row => $row,
528                                    rules => $rules,
529                                    lookup => $lookup_hash,
530                                    config => create_ds_config( $db_config, $database, $input, $mfn ),
531                                    marc_encoding => 'utf-8',
532                                    load_row_coderef => sub {
533                                            my ($database,$input,$mfn) = @_;
534                                            return $store->load_row(
535                                                    database => $database,
536                                                    input => $input,
537                                                    id => $mfn,
538                                            );
539                                    },
540                            );
541    
542                            $log->debug("ds = ", sub { dump($ds) }) if ($ds);
543    
544                            $store->save_ds(
545                                    database => $database,
546                                    input => $input_name,
547                                    id => $mfn,
548                                    ds => $ds,
549                            ) if ($ds && !$stats);
550    
551                          $indexer->add(                          $indexer->add(
552                                  id => $input->{name} . "/" . $mfn,                                  id => "${input_name}/${mfn}",
553                                  ds => $ds,                                  ds => $ds,
554                                  type => $config->{$use_indexer}->{type},                                  type => $config->get($indexer_config)->{type},
555                          );                          ) if ($indexer && $ds);
556    
557                          $total_rows++;                          if ($marc) {
558                                    my $i = 0;
559    
560                                    while (my $fields = WebPAC::Normalize::_get_marc_fields( fetch_next => 1 ) ) {
561                                            $marc->add(
562                                                    id => $mfn . ( $i ? "/$i" : '' ),
563                                                    fields => $fields,
564                                                    leader => WebPAC::Normalize::_get_marc_leader(),
565                                                    row => $row,
566                                            );
567                                            $i++;
568                                    }
569    
570                                    $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
571                            }
572                  }                  }
573    
574          };                  if ($validate) {
575                            my $errors = $validate->report;
576                            if ($errors) {
577                                    $log->info("validation errors:\n$errors\n" );
578                                    print $report_fh "$errors\n" if ($report_fh);
579                            }
580    
581          eval { $indexer->finish } if ($indexer->can('finish'));                          print $report_fh "\nAll possible subfields/delimiter templates:\n", $validate->delimiters_templates( report => 1, current_input => 1 ), "\n\n";
582    
583                            # must be last thing that touches $validate for this input
584                            $validate->reset;
585                    }
586    
587                    if ($stats) {
588                            my $s = $input_db->stats;
589                            $log->info("statistics of fields usage:\n$s");
590                            print $report_fh "Statistics of fields usage:\n$s" if ($report_fh);
591                    }
592    
593                    # close MARC file
594                    $marc->finish if ($marc);
595    
596                    # close report
597                    close($report_fh) if ($report_fh);
598            }
599    
600            eval { $indexer->finish } if ($indexer && $indexer->can('finish'));
601    
602          my $dt = time() - $start_t;          my $dt = time() - $start_t;
603          $log->info("$total_rows records indexed in " .          $log->info("$total_rows records ", $indexer ? "indexed " : "",
604                  sprintf("%.2f sec [%.2f rec/sec]",                  sprintf("in %.2f sec [%.2f rec/sec]",
605                          $dt, ($total_rows / $dt)                          $dt, ($total_rows / $dt)
606                  )                  )
607          );          );
608    
609          #  
610          # add Hyper Estraier links to other databases          # end forked process
611          #          if ($parallel) {
612          if (ref($db_config->{links}) eq 'ARRAY') {                  $log->info("parallel process $$ finished");
613                  foreach my $link (@{ $db_config->{links} }) {                  exit(0);
                         if ($use_indexer eq 'hyperestraier') {  
                                 $log->info("adding link $database -> $link->{to} [$link->{credit}]");  
                                 $indexer->add_link(  
                                         from => $database,  
                                         to => $link->{to},  
                                         credit => $link->{credit},  
                                 );  
                         } else {  
                                 $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");  
                         }  
                 }  
614          }          }
615    
616  }  }
617    
618    if ($parallel) {
619            # wait all children to finish
620            sleep(1) while wait != -1;
621            $log->info("all parallel processes finished");
622    }
623    
624    # save new delimiters if needed
625    $validate->save_delimiters_templates if ( $validate_delimiters_path );
626    
627    #
628    # handle links or merge after indexing
629    #
630    
631    if ($merge) {
632            print $estcmd_fh 'sudo /etc/init.d/hyperestraier start',$/;
633            close($estcmd_fh);
634            chmod 0700, $estcmd_path || $log->warn("can't chmod 0700 $estcmd_path: $!");
635            system $estcmd_path;
636    } else {
637            foreach my $link (@links) {
638                    $log->logdie("coderef in link ", Dumper($link), " is ", ref($link), " and not CODE") unless (ref($link) eq 'CODE');
639                    $link->();
640            }
641    }
Legend:
Removed from v.493  
changed lines
  Added in v.868
  ViewVC Help
Powered by ViewVC 1.1.26