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