/[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 389 by dpavlin, Sun Jan 22 13:38:17 2006 UTC revision 523 by dpavlin, Sun May 21 19:29:26 2006 UTC
# Line 12  use WebPAC::Lookup; Line 12  use WebPAC::Lookup;
12  use WebPAC::Input 0.03;  use WebPAC::Input 0.03;
13  use WebPAC::Store 0.03;  use WebPAC::Store 0.03;
14  use WebPAC::Normalize::XML;  use WebPAC::Normalize::XML;
15    use WebPAC::Normalize::Set;
16  use WebPAC::Output::TT;  use WebPAC::Output::TT;
17  use WebPAC::Output::Estraier 0.08;  use WebPAC::Validate;
18  use YAML qw/LoadFile/;  use YAML qw/LoadFile/;
19  use Getopt::Long;  use Getopt::Long;
20  use File::Path;  use File::Path;
21  use Time::HiRes qw/time/;  use Time::HiRes qw/time/;
22    use File::Slurp;
23    
24  =head1 NAME  =head1 NAME
25    
# Line 41  limit loading to 100 records Line 43  limit loading to 100 records
43    
44  remove database and Hyper Estraier index before indexing  remove database and Hyper Estraier index before indexing
45    
46  =item --one=database_name  =item --only=database_name/input_filter
47    
48  reindex just single database  reindex just single database (legacy name is --one)
49    
50    C</input_filter> is optional part which can be C<name>
51    or C<type> from input
52    
53  =item --config conf/config.yml  =item --config conf/config.yml
54    
55  path to YAML configuration file  path to YAML configuration file
56    
57    =item --force-set
58    
59    force conversion C<< normalize->path >> in C<config.yml> from
60    C<.xml> to C<.pl>
61    
62    =item --stats
63    
64    disable indexing and dump statistics about field and subfield
65    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  =back  =back
72    
73  =cut  =cut
# Line 59  my $limit; Line 78  my $limit;
78  my $clean = 0;  my $clean = 0;
79  my $config = 'conf/config.yml';  my $config = 'conf/config.yml';
80  my $debug = 0;  my $debug = 0;
81  my $one_db_name;  my $only_filter;
82    my $force_set = 0;
83    my $stats = 0;
84    my $validate_path;
85    
86  GetOptions(  GetOptions(
87          "limit=i" => \$limit,          "limit=i" => \$limit,
88          "offset=i" => \$offset,          "offset=i" => \$offset,
89          "clean" => \$clean,          "clean" => \$clean,
90          "one=s" => \$one_db_name,          "one=s" => \$only_filter,
91            "only=s" => \$only_filter,
92          "config" => \$config,          "config" => \$config,
93          "debug" => \$debug,          "debug" => \$debug,
94            "force-set" => \$force_set,
95            "stats" => \$stats,
96            "validate=s" => \$validate_path,
97  );  );
98    
99  $config = LoadFile($config);  $config = LoadFile($config);
# Line 76  print "config = ",Dumper($config) if ($d Line 102  print "config = ",Dumper($config) if ($d
102    
103  die "no databases in config file!\n" unless ($config->{databases});  die "no databases in config file!\n" unless ($config->{databases});
104    
105    my $log = _new WebPAC::Common()->_get_logger();
106    $log->info( "-" x 79 );
107    
108    my $validate;
109    $validate = new WebPAC::Validate(
110            path => $validate_path,
111    ) if ($validate_path);
112    
113    my $use_indexer = $config->{use_indexer} || 'hyperestraier';
114    if ($stats) {
115            $log->debug("option --stats disables update of indexing engine...");
116            $use_indexer = undef;
117    } else {
118            $log->info("using $use_indexer indexing engine...");
119    }
120    
121  my $total_rows = 0;  my $total_rows = 0;
122  my $start_t = time();  my $start_t = time();
123    
124  while (my ($database, $db_config) = each %{ $config->{databases} }) {  while (my ($database, $db_config) = each %{ $config->{databases} }) {
125    
126          next if ($one_db_name && $database !~ m/$one_db_name/i);          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);
127            next if ($only_database && $database !~ m/$only_database/i);
128    
129          my $log = _new WebPAC::Common()->_get_logger();          my $indexer;
130    
131          #          if ($use_indexer) {
132          # open Hyper Estraier database                  my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");
133          #                  $indexer_config->{database} = $database;
134                    $indexer_config->{clean} = $clean;
135                    $indexer_config->{label} = $db_config->{name};
136    
137                    if ($use_indexer eq 'hyperestraier') {
138    
139                            # open Hyper Estraier database
140                            use WebPAC::Output::Estraier '0.10';
141                            $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
142                    
143                    } elsif ($use_indexer eq 'kinosearch') {
144    
145                            # open KinoSearch
146                            use WebPAC::Output::KinoSearch;
147                            $indexer_config->{clean} = 1 unless (-e $indexer_config->{index_path});
148                            $indexer = new WebPAC::Output::KinoSearch( %{ $indexer_config } );
149    
150          my $est_config = $config->{hyperestraier} || $log->logdie("can't find 'hyperestraier' part in confguration");                  } else {
151          $est_config->{database} = $database;                          $log->logdie("unknown use_indexer: $use_indexer");
152          $est_config->{clean} = $clean;                  }
153    
154                    $log->logide("can't continue without valid indexer") unless ($indexer);
155            }
156    
         my $est = new WebPAC::Output::Estraier( %{ $est_config } );  
157    
158          #          #
159          # now WebPAC::Store          # now WebPAC::Store
# Line 104  while (my ($database, $db_config) = each Line 164  while (my ($database, $db_config) = each
164          my $db_path = $config->{webpac}->{db_path} . '/' . $database;          my $db_path = $config->{webpac}->{db_path} . '/' . $database;
165    
166          if ($clean) {          if ($clean) {
167                  $log->info("creating new database $database in $db_path");                  $log->info("creating new database '$database' in $db_path");
168                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");
169          } else {          } else {
170                  $log->info("working on $database in $db_path");                  $log->info("working on database '$database' in $db_path");
171          }          }
172    
173          my $db = new WebPAC::Store(          my $db = new WebPAC::Store(
# Line 134  while (my ($database, $db_config) = each Line 194  while (my ($database, $db_config) = each
194    
195          foreach my $input (@inputs) {          foreach my $input (@inputs) {
196    
197                    next if ($only_input && ($input->{name} !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
198    
199                  my $type = lc($input->{type});                  my $type = lc($input->{type});
200    
201                  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(",", @supported_inputs), " not '$type'!\n" unless (grep(/$type/, @supported_inputs));
202    
203                  my $lookup = new WebPAC::Lookup(                  my $lookup = new WebPAC::Lookup(
204                          lookup_file => $input->{lookup},                          lookup_file => $input->{lookup},
205                  );                  ) if ($input->{lookup});
206    
207                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my $input_module = $config->{webpac}->{inputs}->{$type};
208    
209                  $log->info("working on input $input->{path} [$input->{type}] using $input_module");                  $log->info("working on input '$input->{name}' in $input->{path} [type: $input->{type}] using $input_module",
210                            $input->{lookup} ? "lookup '$input->{lookup}'" : ""
211                    );
212    
213                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
214                          module => $input_module,                          module => $input_module,
# Line 152  while (my ($database, $db_config) = each Line 216  while (my ($database, $db_config) = each
216                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
217                          offset => $offset,                          offset => $offset,
218                          lookup => $lookup,                          lookup => $lookup,
219                            recode => $input->{recode},
220                            stats => $stats,
221                  );                  );
222                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
223    
224                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
225                          path => $input->{path},                          path => $input->{path},
226                          code_page => $input->{encoding},        # database encoding                          code_page => $input->{encoding},        # database encoding
227                            %{ $input },
228                  );                  );
229    
230                  my $n = new WebPAC::Normalize::XML(                  my $n = new WebPAC::Normalize::XML(
231                  #       filter => { 'foo' => sub { shift } },                  #       filter => { 'foo' => sub { shift } },
232                          db => $db,                          db => $db,
233                          lookup_regex => $lookup->regex,                          lookup_regex => $lookup ? $lookup->regex : undef,
234                          lookup => $lookup,                          lookup => $lookup,
235                          prefix => $input->{name},                          prefix => $input->{name},
236                  );                  );
237    
238                    my $rules;
239                  my $normalize_path = $input->{normalize}->{path};                  my $normalize_path = $input->{normalize}->{path};
240    
241                    if ($force_set) {
242                            my $new_norm_path = $normalize_path;
243                            $new_norm_path =~ s/\.xml$/.pl/;
244                            if (-e $new_norm_path) {
245                                    $log->debug("--force-set replaced $normalize_path with $new_norm_path");
246                                    $normalize_path = $new_norm_path;
247                            } else {
248                                    $log->debug("--force-set failed on $new_norm_path, fallback to $normalize_path");
249                            }
250                    }
251    
252                  if ($normalize_path =~ m/\.xml$/i) {                  if ($normalize_path =~ m/\.xml$/i) {
253                          $n->open(                          $n->open(
254                                  tag => $input->{normalize}->{tag},                                  tag => $input->{normalize}->{tag},
255                                  xml_file => $input->{normalize}->{path},                                  xml_file => $normalize_path,
256                          );                          );
257                  } elsif ($normalize_path =~ m/\.(?:yml|yaml)$/i) {                  } elsif ($normalize_path =~ m/\.(?:yml|yaml)$/i) {
258                          $n->open_yaml(                          $n->open_yaml(
259                                  path => $normalize_path,                                  path => $normalize_path,
260                                  tag => $input->{normalize}->{tag},                                  tag => $input->{normalize}->{tag},
261                          );                          );
262                    } elsif ($normalize_path =~ m/\.(?:pl)$/i) {
263                            $n = undef;
264                            $log->info("using WebPAC::Normalize::Set to process $normalize_path");
265                            $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";
266                  }                  }
267    
268                  foreach my $pos ( 0 ... $input_db->size ) {                  foreach my $pos ( 0 ... $input_db->size ) {
# Line 194  while (my ($database, $db_config) = each Line 277  while (my ($database, $db_config) = each
277                                  push @{ $row->{'000'} }, $pos;                                  push @{ $row->{'000'} }, $pos;
278                          }                          }
279    
                         my $ds = $n->data_structure($row);  
280    
281                          $est->add(                          if ($validate) {
282                                    my @errors = $validate->validate_errors( $row );
283                                    $log->error( "MFN $mfn validation errors:\n", join("\n", @errors) ) if (@errors);
284                            }
285    
286                                    
287                            my $ds;
288                            if ($n) {
289                                    $ds = $n->data_structure($row);
290                            } else {
291                                    $ds = WebPAC::Normalize::Set::data_structure(
292                                            row => $row,
293                                            rules => $rules,
294                                            lookup => $lookup ? $lookup->lookup_hash : undef,
295                                    );
296    
297                                    $db->save_ds(
298                                            id => $mfn,
299                                            ds => $ds,
300                                            prefix => $input->{name},
301                                    ) if ($ds && !$stats);
302                            }
303    
304                            $indexer->add(
305                                  id => $input->{name} . "/" . $mfn,                                  id => $input->{name} . "/" . $mfn,
306                                  ds => $ds,                                  ds => $ds,
307                                  type => $config->{hyperestraier}->{type},                                  type => $config->{$use_indexer}->{type},
308                          );                          ) if ($indexer);
309    
310                          $total_rows++;                          $total_rows++;
311                  }                  }
312    
313                    $log->info("statistics of fields usage:\n", $input_db->stats) if ($stats);
314    
315          };          };
316    
317            eval { $indexer->finish } if ($indexer && $indexer->can('finish'));
318    
319          my $dt = time() - $start_t;          my $dt = time() - $start_t;
320          $log->info("$total_rows records indexed in " .          $log->info("$total_rows records ", $indexer ? "indexed " : "",
321                  sprintf("%.2f sec [%.2f rec/sec]",                  sprintf("in %.2f sec [%.2f rec/sec]",
322                          $dt, ($total_rows / $dt)                          $dt, ($total_rows / $dt)
323                  )                  )
324          );          );
# Line 219  while (my ($database, $db_config) = each Line 328  while (my ($database, $db_config) = each
328          #          #
329          if (ref($db_config->{links}) eq 'ARRAY') {          if (ref($db_config->{links}) eq 'ARRAY') {
330                  foreach my $link (@{ $db_config->{links} }) {                  foreach my $link (@{ $db_config->{links} }) {
331                          $log->info("adding link $database -> $link->{to} [$link->{credit}]");                          if ($use_indexer eq 'hyperestraier') {
332                          $est->add_link(                                  $log->info("adding link $database -> $link->{to} [$link->{credit}]");
333                                  from => $database,                                  $indexer->add_link(
334                                  to => $link->{to},                                          from => $database,
335                                  credit => $link->{credit},                                          to => $link->{to},
336                          );                                          credit => $link->{credit},
337                                    );
338                            } else {
339                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
340                            }
341                  }                  }
342          }          }
343    
Legend:
Removed from v.389  
changed lines
  Added in v.523
  ViewVC Help
Powered by ViewVC 1.1.26