- retabify (untabify for pysolv)
[platform/upstream/libsolv.git] / examples / p5solv
1 #!/usr/bin/perl -w
2
3 use POSIX;
4 use Fcntl;
5 use Config::IniFiles;
6 use Data::Dumper;
7 use solv;
8 use Devel::Peek;
9 use FileHandle;
10 use File::Temp ();
11 use strict;
12
13 package Repo::generic;
14
15 sub new {
16   my ($class, $alias, $type, $attr) = @_;
17   my $r = { %{$attr || {}} };
18   $r->{'alias'} = $alias;
19   $r->{'type'} = $type;
20   return bless $r, $class;
21 }
22
23 sub calc_cookie_fp {
24   my ($self, $fp) = @_;
25   my $chksum = solv::Chksum->new($solv::REPOKEY_TYPE_SHA256);
26   $chksum->add_fp($fp);
27   return $chksum->raw();
28 }
29
30 sub calc_cookie_file {
31   my ($self, $filename) = @_;
32   my $chksum = solv::Chksum->new($solv::REPOKEY_TYPE_SHA256);
33   $chksum->add("1.1");
34   $chksum->add_stat($filename);
35   return $chksum->raw();
36 }
37
38 sub cachepath {
39   my ($self, $ext) = @_;
40   my $path = $self->{'alias'};
41   $path =~ s/^\./_/s;
42   $path .= $ext ? "_$ext.solvx" : '.solv';
43   $path =~ s/\//_/gs;
44   return "/var/cache/solv/$path";
45 }
46
47 sub load {
48   my ($self, $pool) = @_;
49   $self->{'handle'} = $pool->add_repo($self->{'alias'});
50   $self->{'handle'}->{'appdata'} = $self;
51   $self->{'handle'}->{'priority'} = 99 - $self->{'priority'};
52   my $dorefresh = $self->{'autorefresh'};
53   if ($dorefresh) {
54     my @s = stat($self->cachepath());
55     $dorefresh = 0 if @s && time() - $s[9] < $self->{'metadata_expire'};
56   }
57   $self->{'cookie'} = '';
58   if (!$dorefresh && $self->usecachedrepo()) {
59     print "repo: '$self->{'alias'}' cached\n";
60     return 1;
61   }
62   return $self->load_if_changed();
63 }
64
65 sub load_if_changed {
66   return 0;
67 }
68
69 sub load_ext {
70   return 0;
71 }
72
73 sub download {
74   my ($self, $file, $uncompress, $chksum, $markincomplete) = @_;
75   if (!$self->{'baseurl'}) {
76     print "$self->{'alias'}: no baseurl\n";
77     return undef;
78   }
79   my $url = $self->{'baseurl'};
80   $url =~ s/\/$//;
81   $url .= "/$file";
82   open(my $f, '+>', undef) || die;
83   fcntl($f, Fcntl::F_SETFD, 0);
84   my $st = system('curl', '-f', '-s', '-L', '-o', "/dev/fd/".fileno($f), '--', $url);
85   if (POSIX::lseek(fileno($f), 0, POSIX::SEEK_END) == 0 && ($st == 0 || !$chksum)) {
86     return undef;
87   }
88   POSIX::lseek(fileno($f), 0, POSIX::SEEK_SET);
89   if ($st) {
90     print "$file: download error #$st\n";
91     $self->{'incomplete'} = 1 if $markincomplete;
92     return undef;
93   }
94   if ($chksum) {
95     my $fchksum = solv::Chksum->new($chksum->{'type'});
96     $fchksum->add_fd(fileno($f));
97     if ($fchksum != $chksum) {
98       print "$file: checksum error\n";
99       $self->{'incomplete'} = 1 if $markincomplete;
100       return undef;
101     }
102   }
103   if ($uncompress) {
104     return solv::xfopen_dup($file, fileno($f));
105   } else {
106     return solv::xfopen_dup(undef, fileno($f));
107   }
108 }
109
110 sub usecachedrepo {
111   my ($self, $ext, $mark) = @_;
112   my $cookie = $ext ? $self->{'extcookie'} : $self->{'cookie'};
113   my $handle = $self->{'handle'};
114   my $cachepath = $self->cachepath($ext);
115   my $fextcookie;
116   if (sysopen(my $f, $cachepath, POSIX::O_RDONLY)) {
117     sysseek($f, -32, Fcntl::SEEK_END);
118     my $fcookie = '';
119     return undef if sysread($f, $fcookie, 32) != 32;
120     return undef if $cookie && $fcookie ne $cookie;
121     if ($self->{'type'} ne 'system' && !$ext) {
122       sysseek($f, -32 * 2, Fcntl::SEEK_END);
123       return undef if sysread($f, $fextcookie, 32) != 32;
124     }
125     sysseek($f, 0, Fcntl::SEEK_SET);
126     my $fd = solv::xfopen_dup(undef, fileno($f));
127     my $flags = $ext ? $solv::Repo::REPO_USE_LOADING|$solv::Repo::REPO_EXTEND_SOLVABLES : 0;
128     $flags |= $solv::Repo::REPO_LOCALPOOL if $ext && $ext ne 'DL';
129     if (!$self->{'handle'}->add_solv($fd, $flags)) {
130       solv::xfclose($fd);
131       return undef;
132     }
133     solv::xfclose($fd);
134     $self->{'cookie'} = $fcookie unless $ext;
135     $self->{'extcookie'} = $fextcookie if $fextcookie;
136     utime undef, undef, $f if $mark;
137     return 1;
138   }
139   return undef;
140 }
141
142 sub genextcookie {
143   my ($self, $f) = @_;
144   my $chksum = solv::Chksum->new($solv::REPOKEY_TYPE_SHA256);
145   $chksum->add($self->{'cookie'});
146   if ($f) {
147     my @s = stat($f);
148     $chksum->add("@s");
149   }
150   my $extcookie = $chksum->raw();
151   substr($extcookie, 0, 1) = chr(1) if ord(substr($extcookie, 0, 1)) == 0;
152   $self->{'extcookie'} = $extcookie;
153 }
154
155 sub writecachedrepo {
156   my ($self, $ext, $info) = @_;
157   mkdir("/var/cache/solv", 0755) unless -d "/var/cache/solv";
158   my ($f, $tmpname);
159   eval {
160     ($f, $tmpname) = File::Temp::tempfile(".newsolv-XXXXXX", 'DIR' => '/var/cache/solv');
161   };
162   return unless $f;
163   chmod 0444, $f;
164   my $ff = solv::xfopen_dup(undef, fileno($f));
165   if (!$info) {
166     $self->{'handle'}->write($ff);
167   } elsif ($ext) {
168     $info->write($ff);
169   } else {
170      $self->{'handle'}->write_first_repodata($ff);
171   }
172   solv::xfclose($ff);
173   if ($self->{'type'} ne 'system' && !$ext) {
174     $self->genextcookie($f) unless $self->{'extcookie'};
175     syswrite($f, $self->{'extcookie'});
176   }
177   syswrite($f, $ext ? $self->{'extcookie'} : $self->{'cookie'});
178   close($f);
179   if ($self->{'handle'}->iscontiguous()) {
180     $f = solv::xfopen($tmpname);
181     if ($f) {
182       if (!$ext) {
183         $self->{'handle'}->empty();
184         die("internal error, cannot reload solv file\n") unless $self->{'handle'}->add_solv($f, $solv::Repo::SOLV_ADD_NO_STUBS);
185       } else {
186         $info->extend_to_repo();
187         $info->add_solv($f, $solv::Repo::REPO_EXTEND_SOLVABLES);
188       }
189       solv::xfclose($f);
190     }
191   }
192   rename($tmpname, $self->cachepath($ext));
193 }
194
195 package Repo::rpmmd;
196
197 our @ISA = ('Repo::generic');
198
199 sub find {
200   my ($self, $what) = @_;
201   my $di = $self->{'handle'}->Dataiterator($solv::SOLVID_META, $solv::REPOSITORY_REPOMD_TYPE, $what, $solv::Dataiterator::SEARCH_STRING);
202   $di->prepend_keyname($solv::REPOSITORY_REPOMD);
203   for my $d (@$di) {
204     my $dp = $d->parentpos();
205     my $filename = $dp->lookup_str($solv::REPOSITORY_REPOMD_LOCATION);
206     next unless $filename;
207     my $chksum = $dp->lookup_checksum($solv::REPOSITORY_REPOMD_CHECKSUM);
208     if (!$chksum) {
209       print "no $filename file checksum!\n";
210       return (undef, undef);
211     }
212     return ($filename, $chksum);
213   }
214   return (undef, undef);
215 }
216
217 sub add_ext {
218   my ($self, $repodata, $what, $ext) = @_;
219   my ($filename, $chksum) = $self->find($what);
220   ($filename, $chksum) = $self->find('prestodelta') if !$filename && $what eq 'deltainfo';
221   return unless $filename;
222   my $handle = $repodata->new_handle();
223   $repodata->set_poolstr($handle, $solv::REPOSITORY_REPOMD_TYPE, $what);
224   $repodata->set_str($handle, $solv::REPOSITORY_REPOMD_LOCATION, $filename);
225   $repodata->set_checksum($handle, $solv::REPOSITORY_REPOMD_CHECKSUM, $chksum);
226   if ($ext eq 'DL') {
227     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::REPOSITORY_DELTAINFO);
228     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::REPOKEY_TYPE_FLEXARRAY);
229   } elsif ($ext eq 'FL') {
230     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::SOLVABLE_FILELIST);
231     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::REPOKEY_TYPE_DIRSTRARRAY);
232   }
233   $repodata->add_flexarray($solv::SOLVID_META, $solv::REPOSITORY_EXTERNAL, $handle);
234 }
235
236 sub add_exts {
237   my ($self) = @_;
238   my $repodata = $self->{'handle'}->add_repodata(0);
239   $self->add_ext($repodata, 'deltainfo', 'DL');
240   $self->add_ext($repodata, 'filelists', 'FL');
241   $repodata->internalize();
242 }
243
244 sub load_ext {
245   my ($self, $repodata) = @_;
246   my $repomdtype = $repodata->lookup_str($solv::SOLVID_META, $solv::REPOSITORY_REPOMD_TYPE);
247   my $ext;
248   if ($repomdtype eq 'filelists') {
249     $ext = 'FL';
250   } elsif ($repomdtype eq 'deltainfo') {
251     $ext = 'DL';
252   } else {
253     return 0;
254   }
255   print("[$self->{'alias'}:$ext: ");
256   STDOUT->flush();
257   if ($self->usecachedrepo($ext)) {
258     print "cached]\n";
259     return 1;
260   }
261   print "fetching]\n";
262   my $filename = $repodata->lookup_str($solv::SOLVID_META, $solv::REPOSITORY_REPOMD_LOCATION);
263   my $filechksum = $repodata->lookup_checksum($solv::SOLVID_META, $solv::REPOSITORY_REPOMD_CHECKSUM);
264   my $f = $self->download($filename, 1, $filechksum);
265   return 0 unless $f;
266   if ($ext eq 'FL') {
267     $self->{'handle'}->add_rpmmd($f, 'FL', $solv::Repo::REPO_USE_LOADING|$solv::Repo::REPO_EXTEND_SOLVABLES);
268   } elsif ($ext eq 'FL') {
269     $self->{'handle'}->add_deltainfoxml($f, $solv::Repo::REPO_USE_LOADING);
270   }
271   solv::xfclose($f);
272   $self->writecachedrepo($ext, $repodata);
273   return 1;
274 }
275
276 sub load_if_changed {
277   my ($self) = @_;
278   print "rpmmd repo '$self->{'alias'}': ";
279   STDOUT->flush();
280   my $f = $self->download("repodata/repomd.xml");
281   if (!$f) {
282     print "no repomd.xml file, skipped\n";
283     $self->{'handle'}->free(1);
284     delete $self->{'handle'};
285     return undef;
286   }
287   $self->{'cookie'} = $self->calc_cookie_fp($f);
288   if ($self->usecachedrepo(undef, 1)) {
289     print "cached\n";
290     solv::xfclose($f);
291     return 1;
292   }
293   $self->{'handle'}->add_repomdxml($f, 0);
294   solv::xfclose($f);
295   print "fetching\n";
296   my ($filename, $filechksum) = $self->find('primary');
297   if ($filename) {
298     $f = $self->download($filename, 1, $filechksum, 1);
299     if ($f) {
300       $self->{'handle'}->add_rpmmd($f, undef, 0);
301       solv::xfclose($f);
302     }
303     return undef if $self->{'incomplete'};
304   }
305   ($filename, $filechksum) = $self->find('updateinfo');
306   if ($filename) {
307     $f = $self->download($filename, 1, $filechksum, 1);
308     if ($f) {
309       $self->{'handle'}->add_updateinfoxml($f, 0);
310       solv::xfclose($f);
311     }
312   }
313   $self->add_exts();
314   $self->writecachedrepo() unless $self->{'incomplete'};
315   $self->{'handle'}->create_stubs();
316   return 1;
317 }
318
319 package Repo::susetags;
320
321 our @ISA = ('Repo::generic');
322
323 sub find {
324   my ($self, $what) = @_;
325   
326   my $di = $self->{'handle'}->Dataiterator($solv::SOLVID_META, $solv::SUSETAGS_FILE_NAME, $what, $solv::Dataiterator::SEARCH_STRING);
327   $di->prepend_keyname($solv::SUSETAGS_FILE);
328   for my $d (@$di) {
329     my $dp = $d->parentpos();
330     my $chksum = $dp->lookup_checksum($solv::SUSETAGS_FILE_CHECKSUM);
331     return ($what, $chksum);
332   }
333   return (undef, undef);
334 }
335
336 my %langtags = (
337   $solv::SOLVABLE_SUMMARY     => $solv::REPOKEY_TYPE_STR,
338   $solv::SOLVABLE_DESCRIPTION => $solv::REPOKEY_TYPE_STR,
339   $solv::SOLVABLE_EULA        => $solv::REPOKEY_TYPE_STR,
340   $solv::SOLVABLE_MESSAGEINS  => $solv::REPOKEY_TYPE_STR,
341   $solv::SOLVABLE_MESSAGEDEL  => $solv::REPOKEY_TYPE_STR,
342   $solv::SOLVABLE_CATEGORY    => $solv::REPOKEY_TYPE_ID,
343 );
344
345 sub add_ext {
346   my ($self, $repodata, $what, $ext) = @_;
347   my ($filename, $chksum) = $self->find($what);
348   my $handle = $repodata->new_handle();
349   $repodata->set_str($handle, $solv::SUSETAGS_FILE_NAME, $filename);
350   $repodata->set_checksum($handle, $solv::SUSETAGS_FILE_CHECKSUM, $chksum);
351   if ($ext eq 'DL') {
352     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::REPOSITORY_DELTAINFO);
353     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::REPOKEY_TYPE_FLEXARRAY);
354   } elsif ($ext eq 'DU') {
355     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::SOLVABLE_DISKUSAGE);
356     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::REPOKEY_TYPE_DIRNUMNUMARRAY);
357   } elsif ($ext eq 'FL') {
358     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::SOLVABLE_FILELIST);
359     $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $solv::REPOKEY_TYPE_DIRSTRARRAY);
360   } else {
361     for my $langid (sort {$a <=> $b} keys %langtags) {
362       $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $self->{'handle'}->{'pool'}->id2langid($langid, $ext, 1));
363       $repodata->add_idarray($handle, $solv::REPOSITORY_KEYS, $langtags{$langid});
364     }
365   }
366   $repodata->add_flexarray($solv::SOLVID_META, $solv::REPOSITORY_EXTERNAL, $handle);
367 }
368
369 sub add_exts {
370   my ($self) = @_;
371   my $repodata = $self->{'handle'}->add_repodata(0);
372   my $di = $self->{'handle'}->Dataiterator($solv::SOLVID_META, $solv::SUSETAGS_FILE_NAME, undef, 0);
373   $di->prepend_keyname($solv::SUSETAGS_FILE);
374   for my $d (@$di) {
375     my $filename = $d->str();
376     next unless $filename && $filename =~ /^packages\.(..)(?:\..*)$/;
377     next if $1 eq 'en' || $1 eq 'gz';
378     $self->add_ext($repodata, $filename, $1);
379   }
380   $repodata->internalize();
381 }
382
383 sub load_ext {
384   my ($self, $repodata) = @_;
385   my $filename = $repodata->lookup_str($solv::SOLVID_META, $solv::SUSETAGS_FILE_NAME);
386   my $ext = substr($filename, 9, 2);
387   print("[$self->{'alias'}:$ext: ");
388   STDOUT->flush();
389   if ($self->usecachedrepo($ext)) {
390     print "cached]\n";
391     return 1;
392   }
393   print "fetching]\n";
394   my $defvendorid = $self->{'handle'}->lookup_id($solv::SOLVID_META, $solv::SUSETAGS_DEFAULTVENDOR);
395   my $descrdir = $self->{'handle'}->lookup_str($solv::SOLVID_META, $solv::SUSETAGS_DESCRDIR) || 'suse/setup/descr'; 
396   my $filechksum = $repodata->lookup_checksum($solv::SOLVID_META, $solv::SUSETAGS_FILE_CHECKSUM);
397   my $f = $self->download("$descrdir/$filename", 1, $filechksum);
398   return 0 unless $f;
399   $self->{'handle'}->add_susetags($f, $defvendorid, $ext, $solv::Repo::REPO_USE_LOADING|$solv::Repo::REPO_EXTEND_SOLVABLES);
400   solv::xfclose($f);
401   $self->writecachedrepo($ext, $repodata);
402   return 1;
403 }
404
405 sub load_if_changed {
406   my ($self) = @_;
407   print "susetags repo '$self->{'alias'}': ";
408   STDOUT->flush();
409   my $f = $self->download("content");
410   if (!$f) {
411     print "no content file, skipped\n";
412     $self->{'handle'}->free(1);
413     delete $self->{'handle'};
414     return undef;
415   }
416   $self->{'cookie'} = $self->calc_cookie_fp($f);
417   if ($self->usecachedrepo(undef, 1)) {
418     print "cached\n";
419     solv::xfclose($f);
420     return 1;
421   }
422   $self->{'handle'}->add_content($f, 0);
423   solv::xfclose($f);
424   print "fetching\n";
425   my $defvendorid = $self->{'handle'}->lookup_id($solv::SOLVID_META, $solv::SUSETAGS_DEFAULTVENDOR);
426   my $descrdir = $self->{'handle'}->lookup_str($solv::SOLVID_META, $solv::SUSETAGS_DESCRDIR) || 'suse/setup/descr'; 
427   my ($filename, $filechksum) = $self->find('packages.gz');
428   ($filename, $filechksum) = $self->find('packages') unless $filename;
429   if ($filename) {
430     $f = $self->download("$descrdir/$filename", 1, $filechksum, 1);
431     if ($f) {
432       $self->{'handle'}->add_susetags($f, $defvendorid, undef, $solv::Repo::REPO_NO_INTERNALIZE|$solv::Repo::SUSETAGS_RECORD_SHARES);
433       solv::xfclose($f);
434       ($filename, $filechksum) = $self->find('packages.en.gz');
435       ($filename, $filechksum) = $self->find('packages.en') unless $filename;
436       if ($filename) {
437         $f = $self->download("$descrdir/$filename", 1, $filechksum, 1);
438         if ($f) {
439           $self->{'handle'}->add_susetags($f, $defvendorid, undef, $solv::Repo::REPO_NO_INTERNALIZE|$solv::Repo::REPO_REUSE_REPODATA|$solv::Repo::REPO_EXTEND_SOLVABLES);
440           solv::xfclose($f);
441         }
442       }
443       $self->{'handle'}->internalize();
444     }
445   }
446   $self->add_exts();
447   $self->writecachedrepo() unless $self->{'incomplete'};
448   $self->{'handle'}->create_stubs();
449   return undef;
450 }
451
452 package Repo::unknown;
453
454 our @ISA = ('Repo::generic');
455
456 sub load {
457   my ($self, $pool) = @_;
458   print "unsupported repo '$self->{'alias'}': skipped\n";
459   return 0;
460 }
461
462 package Repo::system;
463
464 our @ISA = ('Repo::generic');
465
466 sub load {
467   my ($self, $pool) = @_;
468
469   $self->{'handle'} = $pool->add_repo($self->{'alias'});
470   $self->{'handle'}->{'appdata'} = $self;
471   $pool->{'installed'} = $self->{'handle'};
472   print "rpm database: ";
473   $self->{'cookie'} = $self->calc_cookie_file('/var/lib/rpm/Packages');
474   if ($self->usecachedrepo()) {
475     print "cached\n";
476     return 1;
477   }
478   print "reading\n";
479   if (defined(&solv::Repo::add_products)) {
480     $self->{'handle'}->add_products("/etc/products.d", $solv::Repo::REPO_NO_INTERNALIZE);
481   }
482   $self->{'handle'}->add_rpmdb(undef, $solv::Repo::REPO_REUSE_REPODATA);
483   $self->writecachedrepo();
484   return 1;
485 }
486
487 package main;
488
489 sub load_stub {
490   my ($repodata) = @_;
491   my $repo = $repodata->{'repo'}->{'appdata'};
492   return $repo ? $repo->load_ext($repodata) : 0;
493 }
494
495 die("Usage: p5solv COMMAND [ARGS]\n") unless @ARGV;
496 my $cmd = shift @ARGV;
497 $cmd = 'list' if $cmd eq 'li';
498 $cmd = 'install' if $cmd eq 'in';
499 $cmd = 'erase' if $cmd eq 'rm';
500 $cmd = 'verify' if $cmd eq 've';
501 $cmd = 'search' if $cmd eq 'se';
502
503 my @repos;
504 my @reposdirs;
505 if (-d '/etc/zypp/repos.d') {
506   @reposdirs = ( '/etc/zypp/repos.d' );
507 } else {
508   @reposdirs = ( '/etc/yum/repos.d' );
509 }
510 for my $reposdir (@reposdirs) {
511   next unless -d $reposdir;
512   next unless opendir(DIR, $reposdir);
513   for my $reponame (sort(grep {/\.repo$/} readdir(DIR))) {
514     my $cfg = new Config::IniFiles('-file' => "$reposdir/$reponame");
515     for my $alias ($cfg->Sections()) {
516       my $repoattr = {'alias' => $alias, 'enabled' => 0, 'priority' => 99, 'autorefresh' => 1, 'type' => 'rpm-md', 'metadata_expire' => 900};
517       for my $p ($cfg->Parameters($alias)) {
518         $repoattr->{$p} = $cfg->val($alias, $p);
519       }
520       my $repo;
521       if ($repoattr->{'type'} eq 'rpm-md') {
522         $repo = Repo::rpmmd->new($alias, 'repomd', $repoattr);
523       } elsif ($repoattr->{'type'} eq 'yast2') {
524         $repo = Repo::susetags->new($alias, 'susetags', $repoattr);
525       } else {
526         $repo = Repo::unknown->new($alias, 'unknown', $repoattr);
527       }
528       push @repos, $repo;
529     }
530   }
531 }
532
533 my $pool = solv::Pool->new();
534 $pool->setarch((POSIX::uname())[4]);
535 $pool->set_loadcallback(\&load_stub);
536
537 my $sysrepo = Repo::system->new('@System', 'system');
538 $sysrepo->load($pool);
539 for my $repo (@repos) {
540   $repo->load($pool) if $repo->{'enabled'};
541 }
542
543 if ($cmd eq 'search') {
544   my %matches;
545   my $di = $pool->Dataiterator(0, $solv::SOLVABLE_NAME, $ARGV[0], $solv::Dataiterator::SEARCH_SUBSTRING | $solv::Dataiterator::SEARCH_NOCASE);
546   for my $d (@$di) {
547     $matches{$d->{'solvid'}} = 1;
548   }
549   for my $solvid (sort keys %matches) {
550     my $s = $pool->{'solvables'}->[$solvid];
551     print "- ".$s->str()." [$s->{'repo'}->{'name'}] ".$s->lookup_str($solv::SOLVABLE_SUMMARY)."\n";
552   }
553   exit(0);
554 }
555
556 my @addedprovides = $pool->addfileprovides_queue();
557 $pool->createwhatprovides();
558
559 my @jobs;
560 for my $arg (@ARGV) {
561   my $flags = $solv::Selection::SELECTION_NAME | $solv::Selection::SELECTION_PROVIDES | $solv::Selection::SELECTION_GLOB;
562   if ($arg =~ /^\//) {
563     $flags |= $solv::Selection::SELECTION_FILELIST;
564     $flags |= $solv::Selection::SELECTION_INSTALLED_ONLY if $cmd eq 'erase';
565   }
566   my $sel = $pool->select($arg, $flags);
567   if ($sel->isempty()) {
568     $sel = $pool->select($arg, $flags | $solv::Selection::SELECTION_NOCASE);
569     print "[ignoring case for '$arg']\n" unless $sel->isempty();
570   }
571   die("nothing matches '$arg'\n") if $sel->isempty();
572   print "[using file list match for '$arg']\n" if $sel->flags() & $solv::Selection::SELECTION_FILELIST;
573   print "[using capability match for '$arg']\n" if $sel->flags() & $solv::Selection::SELECTION_PROVIDES;
574   push @jobs, $sel->jobs(0);
575 }
576 if (!@jobs && ($cmd eq 'up' || $cmd eq 'dup' || $cmd eq 'verify')) {
577   my $sel = $pool->Selection();
578   $sel->addsimple($solv::Job::SOLVER_SOLVABLE_ALL, 0);
579   push @jobs, $sel->jobs(0);
580 }
581
582 if ($cmd eq 'list' || $cmd eq 'info') {
583   die("no package matched.\n") unless @jobs;
584   for my $job (@jobs) {
585     for my $s ($job->solvables()) {
586       if ($cmd eq 'info') {
587         printf "Name:        %s\n", $s->str();
588         printf "Repo:        %s\n", $s->{'repo'}->{'name'};
589         printf "Summary:     %s\n", $s->lookup_str($solv::SOLVABLE_SUMMARY);
590         my $str = $s->lookup_str($solv::SOLVABLE_URL);
591         printf "Url:         %s\n", $str if $str;
592         $str = $s->lookup_str($solv::SOLVABLE_LICENSE);
593         printf "License:     %s\n", $str if $str;
594         printf "Description:\n%s\n", $s->lookup_str($solv::SOLVABLE_DESCRIPTION);
595       } else {
596         printf "  - %s [%s]\n", $s->str(), $s->{'repo'}->{'name'};
597         printf "    %s\n", $s->lookup_str($solv::SOLVABLE_SUMMARY);
598       }
599     }
600   }
601   exit 0;
602 }
603
604 if ($cmd eq 'install' || $cmd eq 'erase' || $cmd eq 'up' || $cmd eq 'dup' || $cmd eq 'verify') {
605   die("no package matched.\n") unless @jobs;
606   for my $job (@jobs) {
607     if ($cmd eq 'up') {
608       if ($job->{'how'} == $solv::Job::SOLVER_SOLVABLE_ALL || grep {$_->isinstalled()} $job->solvables()) {
609         $job->{'how'} |= $solv::Job::SOLVER_UPDATE;
610       } else {
611         $job->{'how'} |= $solv::Job::SOLVER_INSTALL;
612       }
613     } elsif ($cmd eq 'install') {
614         $job->{'how'} |= $solv::Job::SOLVER_INSTALL;
615     } elsif ($cmd eq 'erase') {
616         $job->{'how'} |= $solv::Job::SOLVER_ERASE;
617     } elsif ($cmd eq 'dup') {
618         $job->{'how'} |= $solv::Job::SOLVER_DISTUPGRADE;
619     } elsif ($cmd eq 'verify') {
620         $job->{'how'} |= $solv::Job::SOLVER_VERIFY;
621     }
622   }
623   my $solver;
624   while (1) {
625     $solver = $pool->Solver();
626     $solver->set_flag($solv::Solver::SOLVER_FLAG_SPLITPROVIDES, 1);
627     $solver->set_flag($solv::Solver::SOLVER_FLAG_ALLOW_UNINSTALL, 1) if $cmd eq 'erase';
628     my @problems = $solver->solve(\@jobs);
629     last unless @problems;
630     for my $problem (@problems) {
631       print "Problem $problem->{'id'}/".@problems.":\n";
632       my $r = $problem->findproblemrule();
633       my $ri = $r->info();
634       print $ri->problemstr()."\n";
635       my @solutions = $problem->solutions();
636       for my $solution (@solutions) {
637         print "  Solution $solution->{'id'}:\n";
638         for my $element ($solution->elements(1)) {
639           print "  - ".$element->str()."\n";
640         }
641         print "\n";
642       }
643       my $sol;
644       while (1) {
645         print "Please choose a solution: ";
646         $sol = <STDIN>;
647         chomp $sol;
648         last if $sol eq 's' || $sol eq 'q' || ($sol =~ /^\d+$/ && $sol >= 1 && $sol <= @solutions);
649       }
650       next if $sol eq 's';
651       exit(1) if $sol eq 'q';
652       my $solution = $solutions[$sol - 1];
653       for my $element ($solution->elements()) {
654         my $newjob = $element->Job();
655         if ($element->{'type'} == $solv::Solver::SOLVER_SOLUTION_JOB) {
656           $jobs[$element->{'jobidx'}] = $newjob;
657         } else {
658           push @jobs, $newjob if $newjob && !grep {$_ == $newjob} @jobs;
659         }
660       }
661     }
662   }
663   my $trans = $solver->transaction();
664   undef $solver;
665   if ($trans->isempty()) {
666     print "Nothing to do.\n";
667     exit 0;
668   }
669   print "\nTransaction summary:\n\n";
670   for my $c ($trans->classify()) {
671     if ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_ERASE) {
672       print "$c->{'count'} erased packages:\n";
673     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_INSTALL) {
674       print "$c->{'count'} installed packages:\n";
675     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_REINSTALLED) {
676       print "$c->{'count'} reinstalled packages:\n";
677     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_DOWNGRADED) {
678       print "$c->{'count'} downgraded packages:\n";
679     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_CHANGED) {
680       print "$c->{'count'} changed packages:\n";
681     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_UPGRADED) {
682       print "$c->{'count'} upgraded packages:\n";
683     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_VENDORCHANGE) {
684       printf "$c->{'count'} vendor changes from '%s' to '%s':\n", $pool->id2str($c->{'fromid'}), $pool->id2str($c->{'toid'});
685     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_ARCHCHANGE) {
686       printf "$c->{'count'} arch changes from '%s' to '%s':\n", $pool->id2str($c->{'fromid'}), $pool->id2str($c->{'toid'});
687     } else {
688       next;
689     }
690     for my $p ($c->solvables()) {
691       if ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_UPGRADED || $c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_DOWNGRADED) {
692         my $other = $trans->othersolvable($p);
693         printf "  - %s -> %s\n", $p->str(), $other->str();
694       } else {
695         printf "  - %s\n", $p->str();
696       }
697     }
698     print "\n";
699   }
700   printf "install size change: %d K\n\n", $trans->calc_installsizechange();
701   while (1) {
702     print("OK to continue (y/n)? ");
703     my $yn = <STDIN>;
704     chomp $yn;
705     last if $yn eq 'y';
706     exit(1) if $yn eq 'n';
707   }
708   my @newpkgs = $trans->newpackages();
709   my %newpkgsfps;
710   if (@newpkgs) {
711     my $downloadsize = 0;
712     $downloadsize += $_->lookup_num($solv::SOLVABLE_DOWNLOADSIZE) for @newpkgs;
713     printf "Downloading %d packages, %d K\n", scalar(@newpkgs), $downloadsize;
714     for my $p (@newpkgs) {
715       my $repo = $p->{'repo'}->{'appdata'};
716       my ($location, $medianr) = $p->lookup_location();
717       next unless $location;
718       if ($repo->{'type'} eq 'susetags') {
719         $location = ($repo->{'handle'}->lookup_str($solv::SOLVID_META, $solv::SUSETAGS_DATADIR) || 'suse') ."/$location";
720       }
721       my $chksum = $p->lookup_checksum($solv::SOLVABLE_CHECKSUM);
722       my $f = $repo->download($location, 0, $chksum);
723       die("\n$repo->{'alias'}: $location not found in repository\n") unless $f;
724       $newpkgsfps{$p->{'id'}} = $f;
725       print ".";
726       STDOUT->flush();
727     }
728     print "\n";
729   }
730   print "Committing transaction:\n\n";
731   $trans->order(0);
732   for my $p ($trans->steps()) {
733     my $steptype = $trans->steptype($p, $solv::Transaction::SOLVER_TRANSACTION_RPM_ONLY);
734     if ($steptype == $solv::Transaction::SOLVER_TRANSACTION_ERASE) {
735       print "erase ".$p->str()."\n";
736       next unless $p->lookup_num($solv::RPM_RPMDBID);
737       my $evr = $p->{'evr'};
738       $evr =~ s/^[0-9]+://;     # strip epoch
739       system('rpm', '-e', '--nodeps', '--nodigest', '--nosignature', "$p->{'name'}-$evr.$p->{'arch'}") && die("rpm failed: $?\n");
740     } elsif ($steptype == $solv::Transaction::SOLVER_TRANSACTION_INSTALL || $steptype == $solv::Transaction::SOLVER_TRANSACTION_MULTIINSTALL) {
741       print "install ".$p->str()."\n";
742       my $f = $newpkgsfps{$p->{'id'}};
743       my $mode = $steptype == $solv::Transaction::SOLVER_TRANSACTION_INSTALL ? '-U' : '-i';
744       system('rpm', $mode, '--force', '--nodeps', '--nodigest', '--nosignature', "/dev/fd/".solv::xfileno($f)) && die("rpm failed: $?\n");
745       solv::xfclose($f);
746       delete $newpkgsfps{$p->{'id'}};
747     }
748   }
749 }
750
751 exit 0;