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 validarch {
 490   my ($pool, $arch) = @_;
 491   return undef unless $arch;
 492   my $id = $pool->str2id($arch, 0);
 493   return $id && $pool->isknownarch($id) ? 1 : undef;
 494 }
 495
 496 sub depglob {
 497   my ($pool, $name, $globname, $globdep) = @_;
 498   my $id = $pool->str2id($name, 0);
 499   if ($id) {
 500     my $match;
 501     for my $s ($pool->whatprovides($id)) {
 502       return $pool->Job($solv::Job::SOLVER_SOLVABLE_NAME, $id) if $globname && $s->{'nameid'} == $id;
 503       $match = 1;
 504     }
 505     if ($match) {
 506       print "[using capability match for '$name']\n" if $globname && $globdep;
 507       return $pool->Job($solv::Job::SOLVER_SOLVABLE_PROVIDES, $id);
 508     }
 509   }
 510   return unless $name =~ /[[*?]/;
 511   if ($globname) {
 512     my %idmatches;
 513     for my $d (@{$pool->Dataiterator(0, $solv::SOLVABLE_NAME, $name, $solv::Dataiterator::SEARCH_GLOB)}) {
 514       my $s = $d->{'solvable'};
 515       $idmatches{$s->{'nameid'}} = 1 if $s->installable();
 516     }
 517     if (%idmatches) {
 518       return map {$pool->Job($solv::Job::SOLVER_SOLVABLE_NAME, $_)} sort(keys %idmatches);
 519     }
 520   }
 521   if ($globdep) {
 522     my @idmatches = $pool->matchprovidingids($name, $solv::Dataiterator::SEARCH_GLOB);
 523     if (@idmatches) {
 524       print "[using capability match for '$name']\n";
 525       return map {$pool->Job($solv::Job::SOLVER_SOLVABLE_PROVIDES, $_)} sort(@idmatches);
 526     }
 527   }
 528   return;
 529 }
 530
 531 sub limitjobs {
 532   my ($pool, $jobs, $flags, $evrstr) = @_;
 533   my @jobs;
 534   my $evr = $pool->str2id($evrstr);
 535   for my $j (@$jobs) {
 536     my $how = $j->{'how'};
 537     my $sel = $how & $solv::Job::SOLVER_SELECTMASK;
 538     my $what = $pool->rel2id($j->{'what'}, $evr, $flags);
 539     if ($flags == $solv::REL_ARCH) {
 540       $how |= $solv::Job::SOLVER_SETARCH;
 541     } elsif ($flags == $solv::REL_EQ && $sel == $solv::Job::SOLVER_SOLVABLE_NAME) {
 542       $how |= $evrstr =~ /-/ ? $solv::Job::SOLVER_SETEVR : $solv::Job::SOLVER_SETEV;
 543     }
 544     push @jobs, $pool->Job($how, $what);
 545   }
 546   return @jobs;
 547 }
 548
 549 sub limitjobs_evrarch {
 550   my ($pool, $jobs, $flags, $evrstr) = @_;
 551   if ($evrstr =~ /^(.+)\.(.+?)$/ && validarch($pool, $2)) {
 552     $evrstr = $1;
 553     $jobs = [ limitjobs($pool, $jobs, $solv::REL_ARCH, $2) ];
 554   }
 555   return limitjobs($pool, $jobs, $flags, $evrstr);
 556 }
 557
 558 sub mkjobs_rel {
 559   my ($pool, $cmd, $name, $rel, $evr) = @_;
 560   my $flags = 0;
 561   $flags |= $solv::REL_LT if $rel =~ /</;
 562   $flags |= $solv::REL_EQ if $rel =~ /=/;
 563   $flags |= $solv::REL_GT if $rel =~ />/;
 564   my @jobs = depglob($pool, $name, 1, 1);
 565   return limitjobs($pool, \@jobs, $flags, $evr) if @jobs;
 566   if (($name =~ /^(.+)\.(.+?)$/s) && validarch($pool, $2)) {
 567     my $arch = $2;
 568     @jobs = depglob($pool, $1, 1, 1);
 569     if (@jobs) {
 570       @jobs = limitjobs($pool, \@jobs, $solv::REL_ARCH, $arch);
 571       return limitjobs($pool, \@jobs, $flags, $evr);
 572     }
 573   }
 574   return ();
 575 }
 576
 577 sub mkjobs_nevra {
 578   my ($pool, $cmd, $arg) = @_;
 579   my @jobs = depglob($pool, $arg, 1, 1);
 580   return @jobs if @jobs;
 581   if (($arg =~ /^(.+)\.(.+?)$/s) && validarch($pool, $2)) {
 582     my $arch = $2;
 583     @jobs = depglob($pool, $1, 1, 1);
 584     return limitjobs($pool, \@jobs, $solv::REL_ARCH, $arch) if @jobs;
 585   }
 586   if ($arg =~ /^(.+)-(.+?)$/s) {
 587     my $evr = $2;
 588     @jobs = depglob($pool, $1, 1, 0);
 589     return limitjobs_evrarch($pool, \@jobs, $solv::REL_EQ, $evr) if @jobs;
 590   }
 591   if ($arg =~ /^(.+)-(.+?-.+?)$/s) {
 592     my $evr = $2;
 593     @jobs = depglob($pool, $1, 1, 0);
 594     return limitjobs_evrarch($pool, \@jobs, $solv::REL_EQ, $evr) if @jobs;
 595   }
 596   return ();
 597 }
 598
 599 sub mkjobs_filelist {
 600   my ($pool, $cmd, $arg) = @_;
 601   my $type = ($arg =~ /[[*?]/) ? $solv::Dataiterator::SEARCH_GLOB : $solv::Dataiterator::SEARCH_STRING;
 602   $type |= $solv::Dataiterator::SEARCH_FILES | $solv::Dataiterator::SEARCH_COMPLETE_FILELIST;
 603   my $di;
 604   if ($cmd eq 'erase') {
 605     $di = $pool->{'installed'}->Dataiterator(0, $solv::SOLVABLE_FILELIST, $arg, $type);
 606   } else {
 607     $di = $pool->Dataiterator(0, $solv::SOLVABLE_FILELIST, $arg, $type);
 608   }
 609   my @matches;
 610   for my $d (@$di) {
 611     my $s = $d->{'solvable'};
 612     next unless $s && $s->installable();
 613     push @matches, $s->{'id'};
 614     $di->skip_solvable();
 615   }
 616   return () unless @matches;
 617   print "[using file list match for '$arg']\n";
 618   if (@matches > 1) {
 619     return $pool->Job($solv::Job::SOLVER_SOLVABLE_ONE_OF, $pool->towhatprovides(\@matches));
 620   } else {
 621     return $pool->Job($solv::Job::SOLVER_SOLVABLE | $solv::Job::SOLVER_NOAUTOSET, $matches[0]);
 622   }
 623 }
 624
 625 sub mkjobs {
 626   my ($pool, $cmd, $arg) = @_;
 627   if ($arg && $arg =~ /^\//) {
 628     my @jobs = mkjobs_filelist($pool, $cmd, $arg);
 629     return @jobs if @jobs;
 630   }
 631   if ($arg =~ /^(.+?)\s*([<=>]+)\s*(.+?)$/s) {
 632     return mkjobs_rel($pool, $cmd, $1, $2, $3);
 633   } else {
 634     return mkjobs_nevra($pool, $cmd, $arg);
 635   }
 636 }
 637
 638 sub load_stub {
 639   my ($repodata) = @_;
 640   my $repo = $repodata->{'repo'}->{'appdata'};
 641   return $repo ? $repo->load_ext($repodata) : 0;
 642 }
 643
 644 die("Usage: p5solv COMMAND [ARGS]\n") unless @ARGV;
 645 my $cmd = shift @ARGV;
 646 $cmd = 'list' if $cmd eq 'li';
 647 $cmd = 'install' if $cmd eq 'in';
 648 $cmd = 'erase' if $cmd eq 'rm';
 649 $cmd = 'verify' if $cmd eq 've';
 650 $cmd = 'search' if $cmd eq 'se';
 651
 652 my @repos;
 653 for my $reposdir ('/etc/zypp/repos.d') {
 654   next unless -d $reposdir;
 655   next unless opendir(DIR, $reposdir);
 656   for my $reponame (sort(grep {/\.repo$/} readdir(DIR))) {
 657     my $cfg = new Config::IniFiles('-file' => "$reposdir/$reponame");
 658     for my $alias ($cfg->Sections()) {
 659       my $repoattr = {'alias' => $alias, 'enabled' => 0, 'priority' => 99, 'autorefresh' => 1, 'type' => 'rpm-md', 'metadata_expire' => 900};
 660       for my $p ($cfg->Parameters($alias)) {
 661         $repoattr->{$p} = $cfg->val($alias, $p);
 662       }
 663       my $repo;
 664       if ($repoattr->{'type'} eq 'rpm-md') {
 665         $repo = Repo::rpmmd->new($alias, 'repomd', $repoattr);
 666       } elsif ($repoattr->{'type'} eq 'yast2') {
 667         $repo = Repo::susetags->new($alias, 'susetags', $repoattr);
 668       } else {
 669         $repo = Repo::unknown->new($alias, 'unknown', $repoattr);
 670       }
 671       push @repos, $repo;
 672     }
 673   }
 674 }
 675
 676 my $pool = solv::Pool->new();
 677 $pool->setarch((POSIX::uname())[4]);
 678 $pool->set_loadcallback(\&load_stub);
 679
 680 my $sysrepo = Repo::system->new('@System', 'system');
 681 $sysrepo->load($pool);
 682 for my $repo (@repos) {
 683   $repo->load($pool) if $repo->{'enabled'};
 684 }
 685
 686 if ($cmd eq 'search') {
 687   my %matches;
 688   my $di = $pool->Dataiterator(0, $solv::SOLVABLE_NAME, $ARGV[0], $solv::Dataiterator::SEARCH_SUBSTRING | $solv::Dataiterator::SEARCH_NOCASE);
 689   for my $d (@$di) {
 690     $matches{$d->{'solvid'}} = 1;
 691   }
 692   for my $solvid (sort keys %matches) {
 693     my $s = $pool->{'solvables'}->[$solvid];
 694     print "- ".$s->str()." [$s->{'repo'}->{'name'}] ".$s->lookup_str($solv::SOLVABLE_SUMMARY)."\n";
 695   }
 696   exit(0);
 697 }
 698
 699 my @addedprovides = $pool->addfileprovides_queue();
 700 $pool->createwhatprovides();
 701
 702 my @jobs;
 703 for my $arg (@ARGV) {
 704   my @njobs = mkjobs($pool, $cmd, $arg);
 705   die("nothing matches '$arg'\n") unless @njobs;
 706   push @jobs, @njobs;
 707 }
 708
 709 if ($cmd eq 'list' || $cmd eq 'info') {
 710   die("no package matched.\n") unless @jobs;
 711   for my $job (@jobs) {
 712     for my $s ($job->solvables()) {
 713       if ($cmd eq 'info') {
 714         printf "Name:        %s\n", $s->str();
 715         printf "Repo:        %s\n", $s->{'repo'}->{'name'};
 716         printf "Summary:     %s\n", $s->lookup_str($solv::SOLVABLE_SUMMARY);
 717         my $str = $s->lookup_str($solv::SOLVABLE_URL);
 718         printf "Url:         %s\n", $str if $str;
 719         $str = $s->lookup_str($solv::SOLVABLE_LICENSE);
 720         printf "License:     %s\n", $str if $str;
 721         printf "Description:\n%s\n", $s->lookup_str($solv::SOLVABLE_DESCRIPTION);
 722       } else {
 723         printf "  - %s [%s]\n", $s->str(), $s->{'repo'}->{'name'};
 724         printf "    %s\n", $s->lookup_str($solv::SOLVABLE_SUMMARY);
 725       }
 726     }
 727   }
 728   exit 0;
 729 }
 730
 731 if ($cmd eq 'install' || $cmd eq 'erase' || $cmd eq 'up' || $cmd eq 'dup' || $cmd eq 'verify') {
 732   if (!@jobs) {
 733     if ($cmd eq 'up' || $cmd eq 'verify' || $cmd eq 'dup') {
 734       push @jobs, $pool->Job($solv::Job::SOLVER_SOLVABLE_ALL, 0);
 735     } else {
 736       die("no package matched.\n");
 737     }
 738   }
 739   for my $job (@jobs) {
 740     if ($cmd eq 'up') {
 741       if ($job->{'how'} == $solv::Job::SOLVER_SOLVABLE_ALL || grep {$_->isinstalled()} $job->solvables()) {
 742         $job->{'how'} |= $solv::Job::SOLVER_UPDATE;
 743       } else {
 744         $job->{'how'} |= $solv::Job::SOLVER_INSTALL;
 745       }
 746     } elsif ($cmd eq 'install') {
 747         $job->{'how'} |= $solv::Job::SOLVER_INSTALL;
 748     } elsif ($cmd eq 'erase') {
 749         $job->{'how'} |= $solv::Job::SOLVER_ERASE;
 750     } elsif ($cmd eq 'dup') {
 751         $job->{'how'} |= $solv::Job::SOLVER_DISTUPGRADE;
 752     } elsif ($cmd eq 'verify') {
 753         $job->{'how'} |= $solv::Job::SOLVER_VERIFY;
 754     }
 755   }
 756   my $solver;
 757   while (1) {
 758     $solver = $pool->Solver();
 759     $solver->set_flag($solv::Solver::SOLVER_FLAG_SPLITPROVIDES, 1);
 760     $solver->set_flag($solv::Solver::SOLVER_FLAG_ALLOW_UNINSTALL, 1) if $cmd eq 'erase';
 761     my @problems = $solver->solve(\@jobs);
 762     last unless @problems;
 763     for my $problem (@problems) {
 764       print "Problem $problem->{'id'}/".@problems.":\n";
 765       my $r = $problem->findproblemrule();
 766       my $ri = $r->info();
 767       print $ri->problemstr()."\n";
 768       my @solutions = $problem->solutions();
 769       for my $solution (@solutions) {
 770         print "  Solution $solution->{'id'}:\n";
 771         for my $element ($solution->elements(1)) {
 772           print "  - ".$element->str()."\n";
 773         }
 774         print "\n";
 775       }
 776       my $sol;
 777       while (1) {
 778         print "Please choose a solution: ";
 779         $sol = <STDIN>;
 780         chomp $sol;
 781         last if $sol eq 's' || $sol eq 'q' || ($sol =~ /^\d+$/ && $sol >= 1 && $sol <= @solutions);
 782       }
 783       next if $sol eq 's';
 784       exit(1) if $sol eq 'q';
 785       my $solution = $solutions[$sol - 1];
 786       for my $element ($solution->elements()) {
 787         my $newjob = $element->Job();
 788         if ($element->{'type'} == $solv::Solver::SOLVER_SOLUTION_JOB) {
 789           $jobs[$element->{'jobidx'}] = $newjob;
 790         } else {
 791           push @jobs, $newjob if $newjob && !grep {$_ == $newjob} @jobs;
 792         }
 793       }
 794     }
 795   }
 796   my $trans = $solver->transaction();
 797   undef $solver;
 798   if ($trans->isempty()) {
 799     print "Nothing to do.\n";
 800     exit 0;
 801   }
 802   print "\nTransaction summary:\n\n";
 803   for my $c ($trans->classify()) {
 804     if ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_ERASE) {
 805       print "$c->{'count'} erased packages:\n";
 806     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_INSTALL) {
 807       print "$c->{'count'} installed packages:\n";
 808     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_REINSTALLED) {
 809       print "$c->{'count'} reinstalled packages:\n";
 810     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_DOWNGRADED) {
 811       print "$c->{'count'} downgraded packages:\n";
 812     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_CHANGED) {
 813       print "$c->{'count'} changed packages:\n";
 814     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_UPGRADED) {
 815       print "$c->{'count'} upgraded packages:\n";
 816     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_VENDORCHANGE) {
 817       printf "$c->{'count'} vendor changes from '%s' to '%s':\n", $pool->id2str($c->{'fromid'}), $pool->id2str($c->{'toid'});
 818     } elsif ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_ARCHCHANGE) {
 819       printf "$c->{'count'} arch changes from '%s' to '%s':\n", $pool->id2str($c->{'fromid'}), $pool->id2str($c->{'toid'});
 820     } else {
 821       next;
 822     }
 823     for my $p ($c->solvables()) {
 824       if ($c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_UPGRADED || $c->{'type'} == $solv::Transaction::SOLVER_TRANSACTION_DOWNGRADED) {
 825         my $other = $trans->othersolvable($p);
 826         printf "  - %s -> %s\n", $p->str(), $other->str();
 827       } else {
 828         printf "  - %s\n", $p->str();
 829       }
 830     }
 831     print "\n";
 832   }
 833   printf "install size change: %d K\n\n", $trans->calc_installsizechange();
 834   while (1) {
 835     print("OK to continue (y/n)? ");
 836     my $yn = <STDIN>;
 837     chomp $yn;
 838     last if $yn eq 'y';
 839     exit(1) if $yn eq 'n';
 840   }
 841   my @newpkgs = $trans->newpackages();
 842   my %newpkgsfps;
 843   if (@newpkgs) {
 844     my $downloadsize = 0;
 845     $downloadsize += $_->lookup_num($solv::SOLVABLE_DOWNLOADSIZE) for @newpkgs;
 846     printf "Downloading %d packages, %d K\n", scalar(@newpkgs), $downloadsize;
 847     for my $p (@newpkgs) {
 848       my $repo = $p->{'repo'}->{'appdata'};
 849       my ($location, $medianr) = $p->lookup_location();
 850       next unless $location;
 851       if ($repo->{'type'} eq 'susetags') {
 852         $location = ($repo->{'handle'}->lookup_str($solv::SOLVID_META, $solv::SUSETAGS_DATADIR) || 'suse') ."/$location";
 853       }
 854       my $chksum = $p->lookup_checksum($solv::SOLVABLE_CHECKSUM);
 855       my $f = $repo->download($location, 0, $chksum);
 856       die("\n$repo->{'alias'}: $location not found in repository\n") unless $f;
 857       $newpkgsfps{$p->{'id'}} = $f;
 858       print ".";
 859       STDOUT->flush();
 860     }
 861     print "\n";
 862   }
 863   print "Committing transaction:\n\n";
 864   $trans->order(0);
 865   for my $p ($trans->steps()) {
 866     my $steptype = $trans->steptype($p, $solv::Transaction::SOLVER_TRANSACTION_RPM_ONLY);
 867     if ($steptype == $solv::Transaction::SOLVER_TRANSACTION_ERASE) {
 868       print "erase ".$p->str()."\n";
 869       next unless $p->lookup_num($solv::RPM_RPMDBID);
 870       my $evr = $p->{'evr'};
 871       $evr =~ s/^[0-9]+://;     # strip epoch
 872       system('rpm', '-e', '--nodeps', '--nodigest', '--nosignature', "$p->{'name'}-$evr.$p->{'arch'}") && die("rpm failed: $?\n");
 873     } elsif ($steptype == $solv::Transaction::SOLVER_TRANSACTION_INSTALL || $steptype == $solv::Transaction::SOLVER_TRANSACTION_MULTIINSTALL) {
 874       print "install ".$p->str()."\n";
 875       my $f = $newpkgsfps{$p->{'id'}};
 876       my $mode = $steptype == $solv::Transaction::SOLVER_TRANSACTION_INSTALL ? '-U' : '-i';
 877       system('rpm', $mode, '--force', '--nodeps', '--nodigest', '--nosignature', "/dev/fd/".solv::xfileno($f)) && die("rpm failed: $?\n");
 878       solv::xfclose($f);
 879       delete $newpkgsfps{$p->{'id'}};
 880     }
 881   }
 882 }
 883
 884 exit 0;