/[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 529 by dpavlin, Mon May 22 19:34:45 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    my @links;
125    my $indexer;
126    
127  while (my ($database, $db_config) = each %{ $config->{databases} }) {  while (my ($database, $db_config) = each %{ $config->{databases} }) {
128    
129          next if ($one_db_name && $database !~ m/$one_db_name/i);          my ($only_database,$only_input) = split(m#/#, $only_filter) if ($only_filter);
130            next if ($only_database && $database !~ m/$only_database/i);
131    
132          my $log = _new WebPAC::Common()->_get_logger();          if ($use_indexer) {
133                    my $indexer_config = $config->{$use_indexer} || $log->logdie("can't find '$use_indexer' part in confguration");
134                    $indexer_config->{database} = $database;
135                    $indexer_config->{clean} = $clean;
136                    $indexer_config->{label} = $db_config->{name};
137    
138                    if ($use_indexer eq 'hyperestraier') {
139    
140                            # open Hyper Estraier database
141                            use WebPAC::Output::Estraier '0.10';
142                            $indexer = new WebPAC::Output::Estraier( %{ $indexer_config } );
143                    
144                    } elsif ($use_indexer eq 'kinosearch') {
145    
146                            # open KinoSearch
147                            use WebPAC::Output::KinoSearch;
148                            $indexer_config->{clean} = 1 unless (-e $indexer_config->{index_path});
149                            $indexer = new WebPAC::Output::KinoSearch( %{ $indexer_config } );
150    
151          #                  } else {
152          # open Hyper Estraier database                          $log->logdie("unknown use_indexer: $use_indexer");
153          #                  }
154    
155          my $est_config = $config->{hyperestraier} || $log->logdie("can't find 'hyperestraier' part in confguration");                  $log->logide("can't continue without valid indexer") unless ($indexer);
156          $est_config->{database} = $database;          }
         $est_config->{clean} = $clean;  
157    
         my $est = new WebPAC::Output::Estraier( %{ $est_config } );  
158    
159          #          #
160          # now WebPAC::Store          # now WebPAC::Store
# Line 104  while (my ($database, $db_config) = each Line 165  while (my ($database, $db_config) = each
165          my $db_path = $config->{webpac}->{db_path} . '/' . $database;          my $db_path = $config->{webpac}->{db_path} . '/' . $database;
166    
167          if ($clean) {          if ($clean) {
168                  $log->info("creating new database $database in $db_path");                  $log->info("creating new database '$database' in $db_path");
169                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");                  rmtree( $db_path ) || $log->warn("can't remove $db_path: $!");
170          } else {          } else {
171                  $log->info("working on $database in $db_path");                  $log->info("working on database '$database' in $db_path");
172          }          }
173    
174          my $db = new WebPAC::Store(          my $db = new WebPAC::Store(
# Line 134  while (my ($database, $db_config) = each Line 195  while (my ($database, $db_config) = each
195    
196          foreach my $input (@inputs) {          foreach my $input (@inputs) {
197    
198                    next if ($only_input && ($input->{name} !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
199    
200                  my $type = lc($input->{type});                  my $type = lc($input->{type});
201    
202                  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));
203    
204                  my $lookup = new WebPAC::Lookup(                  my $lookup = new WebPAC::Lookup(
205                          lookup_file => $input->{lookup},                          lookup_file => $input->{lookup},
206                  );                  ) if ($input->{lookup});
207    
208                  my $input_module = $config->{webpac}->{inputs}->{$type};                  my $input_module = $config->{webpac}->{inputs}->{$type};
209    
210                  $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",
211                            $input->{lookup} ? "lookup '$input->{lookup}'" : ""
212                    );
213    
214                  my $input_db = new WebPAC::Input(                  my $input_db = new WebPAC::Input(
215                          module => $input_module,                          module => $input_module,
# Line 152  while (my ($database, $db_config) = each Line 217  while (my ($database, $db_config) = each
217                          limit => $limit || $input->{limit},                          limit => $limit || $input->{limit},
218                          offset => $offset,                          offset => $offset,
219                          lookup => $lookup,                          lookup => $lookup,
220                            recode => $input->{recode},
221                            stats => $stats,
222                  );                  );
223                  $log->logdie("can't create input using $input_module") unless ($input);                  $log->logdie("can't create input using $input_module") unless ($input);
224    
225                  my $maxmfn = $input_db->open(                  my $maxmfn = $input_db->open(
226                          path => $input->{path},                          path => $input->{path},
227                          code_page => $input->{encoding},        # database encoding                          code_page => $input->{encoding},        # database encoding
228                            %{ $input },
229                  );                  );
230    
231                  my $n = new WebPAC::Normalize::XML(                  my $n = new WebPAC::Normalize::XML(
232                  #       filter => { 'foo' => sub { shift } },                  #       filter => { 'foo' => sub { shift } },
233                          db => $db,                          db => $db,
234                          lookup_regex => $lookup->regex,                          lookup_regex => $lookup ? $lookup->regex : undef,
235                          lookup => $lookup,                          lookup => $lookup,
236                          prefix => $input->{name},                          prefix => $input->{name},
237                  );                  );
238    
239                    my $rules;
240                  my $normalize_path = $input->{normalize}->{path};                  my $normalize_path = $input->{normalize}->{path};
241    
242                    if ($force_set) {
243                            my $new_norm_path = $normalize_path;
244                            $new_norm_path =~ s/\.xml$/.pl/;
245                            if (-e $new_norm_path) {
246                                    $log->debug("--force-set replaced $normalize_path with $new_norm_path");
247                                    $normalize_path = $new_norm_path;
248                            } else {
249                                    $log->debug("--force-set failed on $new_norm_path, fallback to $normalize_path");
250                            }
251                    }
252    
253                  if ($normalize_path =~ m/\.xml$/i) {                  if ($normalize_path =~ m/\.xml$/i) {
254                          $n->open(                          $n->open(
255                                  tag => $input->{normalize}->{tag},                                  tag => $input->{normalize}->{tag},
256                                  xml_file => $input->{normalize}->{path},                                  xml_file => $normalize_path,
257                          );                          );
258                  } elsif ($normalize_path =~ m/\.(?:yml|yaml)$/i) {                  } elsif ($normalize_path =~ m/\.(?:yml|yaml)$/i) {
259                          $n->open_yaml(                          $n->open_yaml(
260                                  path => $normalize_path,                                  path => $normalize_path,
261                                  tag => $input->{normalize}->{tag},                                  tag => $input->{normalize}->{tag},
262                          );                          );
263                    } elsif ($normalize_path =~ m/\.(?:pl)$/i) {
264                            $n = undef;
265                            $log->info("using WebPAC::Normalize::Set to process $normalize_path");
266                            $rules = read_file( $normalize_path ) or die "can't open $normalize_path: $!";
267                  }                  }
268    
269                  foreach my $pos ( 0 ... $input_db->size ) {                  foreach my $pos ( 0 ... $input_db->size ) {
# Line 194  while (my ($database, $db_config) = each Line 278  while (my ($database, $db_config) = each
278                                  push @{ $row->{'000'} }, $pos;                                  push @{ $row->{'000'} }, $pos;
279                          }                          }
280    
                         my $ds = $n->data_structure($row);  
281    
282                          $est->add(                          if ($validate) {
283                                    my @errors = $validate->validate_errors( $row );
284                                    $log->error( "MFN $mfn validation errors:\n", join("\n", @errors) ) if (@errors);
285                            }
286    
287                                    
288                            my $ds;
289                            if ($n) {
290                                    $ds = $n->data_structure($row);
291                            } else {
292                                    $ds = WebPAC::Normalize::Set::data_structure(
293                                            row => $row,
294                                            rules => $rules,
295                                            lookup => $lookup ? $lookup->lookup_hash : undef,
296                                    );
297    
298                                    $db->save_ds(
299                                            id => $mfn,
300                                            ds => $ds,
301                                            prefix => $input->{name},
302                                    ) if ($ds && !$stats);
303                            }
304    
305                            $indexer->add(
306                                  id => $input->{name} . "/" . $mfn,                                  id => $input->{name} . "/" . $mfn,
307                                  ds => $ds,                                  ds => $ds,
308                                  type => $config->{hyperestraier}->{type},                                  type => $config->{$use_indexer}->{type},
309                          );                          ) if ($indexer);
310    
311                          $total_rows++;                          $total_rows++;
312                  }                  }
313    
314                    $log->info("statistics of fields usage:\n", $input_db->stats) if ($stats);
315    
316          };          };
317    
318            eval { $indexer->finish } if ($indexer && $indexer->can('finish'));
319    
320          my $dt = time() - $start_t;          my $dt = time() - $start_t;
321          $log->info("$total_rows records indexed in " .          $log->info("$total_rows records ", $indexer ? "indexed " : "",
322                  sprintf("%.2f sec [%.2f rec/sec]",                  sprintf("in %.2f sec [%.2f rec/sec]",
323                          $dt, ($total_rows / $dt)                          $dt, ($total_rows / $dt)
324                  )                  )
325          );          );
# Line 219  while (my ($database, $db_config) = each Line 329  while (my ($database, $db_config) = each
329          #          #
330          if (ref($db_config->{links}) eq 'ARRAY') {          if (ref($db_config->{links}) eq 'ARRAY') {
331                  foreach my $link (@{ $db_config->{links} }) {                  foreach my $link (@{ $db_config->{links} }) {
332                          $log->info("adding link $database -> $link->{to} [$link->{credit}]");                          if ($use_indexer eq 'hyperestraier') {
333                          $est->add_link(                                  $log->info("saving link $database -> $link->{to} [$link->{credit}]");
334                                  from => $database,                                  push @links, {
335                                  to => $link->{to},                                          from => $database,
336                                  credit => $link->{credit},                                          to => $link->{to},
337                          );                                          credit => $link->{credit},
338                                    };
339                            } else {
340                                    $log->warn("NOT IMPLEMENTED WITH $use_indexer: adding link $database -> $link->{to} [$link->{credit}]");
341                            }
342                  }                  }
343          }          }
344    
345  }  }
346    
347    foreach my $link (@links) {
348            $log->info("adding link $link->{from} -> $link->{to} [$link->{credit}]");
349            $indexer->add_link( %{ $link } );
350    }
Legend:
Removed from v.389  
changed lines
  Added in v.529
  ViewVC Help
Powered by ViewVC 1.1.26