/[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 856 by dpavlin, Sun May 27 16:00:26 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  my $use_indexer = $config->{use_indexer} || 'hyperestraier';  $log->info( "-" x 79 );
161  $log->info("using $use_indexer indexing engine...");  
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;
179    $validate = new WebPAC::Validate(
180            path => $validate_path,
181            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;
186    $stats ||= $validate;
187    if ($stats) {
188            $log->debug("disabled indexing for stats collection");
189            $use_indexer = undef;
190    } else {
191            $log->info("using $use_indexer indexing engine...");
192    }
193    
194    # parse normalize files and create source files for lookup and normalization
195    
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  while (my ($database, $db_config) = each %{ $config->{databases} }) {  my @links;
202    
203    if ($parallel) {
204            $log->info("Using $parallel processes for speedup");
205            Proc::Queue::size($parallel);
206    }
207    
208    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);
220            next if ($only_database && $database !~ m/$only_database/i);
221    
222          next if ($only_db_name && $database !~ m/$only_db_name/i);          if ($parallel) {
223                    my $f=fork;
224                    if(defined ($f) and $f==0) {
225                            $log->info("Created processes $$ for speedup");
226                    } else {
227                            next;
228                    }
229            }
230    
231          my $indexer;          my $indexer;
232            if ($use_indexer && $parser->have_rules( 'search', $database )) {
233    
234          my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");                  my $cfg_name = $use_indexer;
235          $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') {  
236    
237                  # open KinoSearch                  my $indexer_config = $config->get( $cfg_name ) || $log->logdie("can't find '$cfg_name' part in confguration");
238                  use WebPAC::Output::KinoSearch;                  $indexer_config->{database} = $database;
239                  $indexer_config->{clean} = 1 unless (-e $indexer_config->{index_path});                  $indexer_config->{clean} = $clean;
240                  $indexer = new WebPAC::Output::KinoSearch( %{ $indexer_config } );                  $indexer_config->{label} = $db_config->{name};
241    
242          } else {                  # force clean if database has links
243                  $log->logdie("unknown use_indexer: $use_indexer");                  $indexer_config->{clean} = 1 if ($db_config->{links});
244    
245                    if ($use_indexer eq 'hyperestraier') {
246    
247                            # open Hyper Estraier database
248                            use WebPAC::Output::Estraier '0.10';
249                            $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') {
258    
259                            # open KinoSearch
260                            use WebPAC::Output::KinoSearch;
261                            $indexer_config->{clean} = 1 unless (-e $indexer_config->{index_path});
262                            $indexer = new WebPAC::Output::KinoSearch( %{ $indexer_config } );
263    
264                    } else {
265                            $log->logdie("unknown use_indexer: $use_indexer");
266                    }
267    
268                    $log->logide("can't continue without valid indexer") unless ($indexer);
269          }          }
270    
271          $log->logide("can't continue without valid indexer") unless ($indexer);  
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
# Line 132  while (my ($database, $db_config) = each Line 302  while (my ($database, $db_config) = each
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");
309                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");
310          } else {          } else {
311                  $log->debug("working on $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 161  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                    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 = new WebPAC::Lookup(                  my $input_module = $config->webpac('inputs')->{$type};
344                          lookup_file => $input->{lookup},  
345                  );                  my @lookups = $parser->have_lookup_create($database, $input);
346    
347                  my $input_module = $config->{webpac}->{inputs}->{$type};                  $log->info("working on input '$input_name' in $input->{path} [type: $input->{type}] using $input_module",
348                            @lookups ? " creating lookups: ".join(", ", @lookups) : ""
349                    );
350    
351                  $log->info("working on input '$input->{path}' [$input->{type}] using $input_module lookup '$input->{lookup}'");                  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                          code_page => $config->{webpac}->{webpac_encoding},                          encoding => $config->webpac('webpac_encoding'),
360                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
361                          offset => $offset,                          offset => $offset,
                         lookup => $lookup,  
362                          recode => $input->{recode},                          recode => $input->{recode},
363                            stats => $stats,
364                            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 },
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    
452                    my $marc;
453                    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,
457                                    dump => $marc_dump,
458                          );                          );
                 } 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: $!";  
459                  }                  }
460    
461                    my $rules = $parser->normalize_rules($database,$input_name) || $log->logdie("no normalize rules found for $database/$input_name");
462                    $log->debug("parsed normalize rules:\n$rules");
463    
464                    # reset position in database
465                    $input_db->seek(1);
466    
467                    # 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                            $log->debug("lookup_hash = ", sub { dump( $lookup_hash ) });
494                    }
495    
496    
497                  foreach my $pos ( 0 ... $input_db->size ) {                  foreach my $pos ( 0 ... $input_db->size ) {
498    
499                          my $row = $input_db->fetch || next;                          my $row = $input_db->fetch || next;
500    
501                            $total_rows++;
502    
503                          my $mfn = $row->{'000'}->[0];                          my $mfn = $row->{'000'}->[0];
504    
505                          if (! $mfn || $mfn !~ m#^\d+$#) {                          if (! $mfn || $mfn !~ m#^\d+$#) {
# Line 242  while (my ($database, $db_config) = each Line 508  while (my ($database, $db_config) = each
508                                  push @{ $row->{'000'} }, $pos;                                  push @{ $row->{'000'} }, $pos;
509                          }                          }
510    
511                          my $ds = $n ? $n->data_structure($row) :  
512                                  WebPAC::Normalize::Set::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_hash,                                                  $validate->report_error( $errors )
516                                  );                                          );
517                                    }
518                                    next;   # validation doesn't create any output
519                            }
520    
521                            my $ds = WebPAC::Normalize::data_structure(
522                                    row => $row,
523                                    rules => $rules,
524                                    lookup => $lookup_hash,
525                                    config => create_ds_config( $db_config, $database, $input, $mfn ),
526                                    marc_encoding => 'utf-8',
527                                    load_row_coderef => sub {
528                                            my ($database,$input,$mfn) = @_;
529                                            return $store->load_row(
530                                                    database => $database,
531                                                    input => $input,
532                                                    id => $mfn,
533                                            );
534                                    },
535                            );
536    
537                            $log->debug("ds = ", sub { dump($ds) }) if ($ds);
538    
539                            $store->save_ds(
540                                    database => $database,
541                                    input => $input_name,
542                                    id => $mfn,
543                                    ds => $ds,
544                            ) if ($ds && !$stats);
545    
546                          $indexer->add(                          $indexer->add(
547                                  id => $input->{name} . "/" . $mfn,                                  id => "${input_name}/${mfn}",
548                                  ds => $ds,                                  ds => $ds,
549                                  type => $config->{$use_indexer}->{type},                                  type => $config->get($indexer_config)->{type},
550                          );                          ) if ($indexer && $ds);
551    
552                          $total_rows++;                          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                                    $log->info("Created $i instances of MFN $mfn\n") if ($i > 1);
566                            }
567                  }                  }
568    
569          };                  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          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";
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'));
596    
597          my $dt = time() - $start_t;          my $dt = time() - $start_t;
598          $log->info("$total_rows records indexed in " .          $log->info("$total_rows records ", $indexer ? "indexed " : "",
599                  sprintf("%.2f sec [%.2f rec/sec]",                  sprintf("in %.2f sec [%.2f rec/sec]",
600                          $dt, ($total_rows / $dt)                          $dt, ($total_rows / $dt)
601                  )                  )
602          );          );
603    
604          #  
605          # add Hyper Estraier links to other databases          # end forked process
606          #          if ($parallel) {
607          if (ref($db_config->{links}) eq 'ARRAY') {                  $log->info("parallel process $$ finished");
608                  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}]");  
                         }  
                 }  
609          }          }
610    
611  }  }
612    
613    if ($parallel) {
614            # wait all children to finish
615            sleep(1) while wait != -1;
616            $log->info("all parallel processes finished");
617    }
618    
619    # save new delimiters if needed
620    $validate->save_delimiters_templates if ( $validate );
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.493  
changed lines
  Added in v.856
  ViewVC Help
Powered by ViewVC 1.1.26