diff options
Diffstat (limited to 'perl-install/install/pkgs.pm')
| -rw-r--r-- | perl-install/install/pkgs.pm | 1132 |
1 files changed, 1132 insertions, 0 deletions
diff --git a/perl-install/install/pkgs.pm b/perl-install/install/pkgs.pm new file mode 100644 index 000000000..a9692e225 --- /dev/null +++ b/perl-install/install/pkgs.pm @@ -0,0 +1,1132 @@ +package install::pkgs; + +use strict; +use feature 'state'; + +BEGIN { + # needed before "use URPM" + mkdir '/etc/rpm'; + symlink "/tmp/stage2/etc/rpm/$_", "/etc/rpm/$_" foreach 'macros.d'; +} + +use URPM; +use URPM::Resolve; +use URPM::Signature; +use urpm; +use urpm::args; +use urpm::main_loop; +use urpm::select; +use common; +use install::any; +use install::media qw(getFile_ getAndSaveFile_ packageMedium); +use run_program; +use detect_devices; +use log; +use fs; +use fs::any; +use fs::loopback; +use c; + +#- lower bound on the left ( aka 90 means [90-100[ ) +our %compssListDesc = ( + 5 => N_("must have"), + 4 => N_("important"), + 3 => N_("very nice"), + 2 => N_("nice"), + 1 => N_("maybe"), +); + +#- TODO BEFORE TODO +#- size and correction size functions for packages. +my $B = 120873; +my $C = 498663; #- does not take hdlist's into account as getAvailableSpace will do it. +my $D = 100000; +sub correctSize { ($B * $_[0] + $C) / $D } +sub invCorrectSize { ($_[0] * $D - $C) / $B } + +sub selectedSize { + my ($packages) = @_; + my $size = 0; + my %skip; + #- take care of packages selected... + foreach (@{$packages->{depslist}}) { + if ($_->flag_selected) { + $size += $_->size; + #- if a package is obsoleted with the same name it should + #- have been selected, so a selected new package obsoletes + #- all the old package. + exists $skip{$_->name} and next; $skip{$_->name} = undef; + $size -= $packages->{sizes}{$_->name}; + } + } + #- but remove size of package being obsoleted or removed. + foreach (keys %{$packages->{state}{rejected}}) { + my ($name) = /(.*)-[^\-]*-[^\-]*$/ or next; + exists $skip{$name} and next; $skip{$name} = undef; + $size -= $packages->{sizes}{$name}; + } + $size; +} + +sub size2time { + my ($x, $max) = @_; + my $A = 7e9; + my $limit = min($max * 3 / 4, 9e8); + if ($x < $limit) { + $A * $x; + } else { + $x -= $limit; + my $B = 6; + my $C = 15e9; + $B * $x ** 2 + $C * $x + $A * $limit; + } +} + +# Based on Rpmdrake::pkg::extract_header(): +sub get_pkg_info { + my ($p) = @_; + + my $urpm = $::o->{packages}; + my $name = $p->fullname; + + my $medium = URPM::pkg2media($urpm->{media}, $p); + my ($local_source, %xml_info_pkgs, $description); + my $dir = urpm::file_from_local_url($medium->{url}); + $local_source = "$dir/" . $p->filename if $dir; + + if (-s $local_source) { + log::l("getting information from $dir..."); + $p->update_header($local_source) and $description = $p->description; + log::l("Warning, could not extract header for $name from $medium!") if !$description; + } + if (!$description) { + my $_w = $::o->wait_message(undef, N("Getting package information from XML meta-data...")); + if (my $xml_info_file = eval { urpm::media::any_xml_info($urpm, $medium, 'info', undef, urpm::download::sync_logger) }) { + require urpm::xml_info; + require urpm::xml_info_pkg; + log::l("getting information from $xml_info_file"); + my %nodes = eval { urpm::xml_info::get_nodes('info', $xml_info_file, [ $name ]) }; + goto header_non_available if $@; + put_in_hash($xml_info_pkgs{$name} ||= {}, $nodes{$name}); + } else { + $urpm->{info}(N("No xml info for medium \"%s\", only partial result for package %s", $medium->{name}, $name)); + } + } + + if (!$description && $xml_info_pkgs{$name}) { + $description = $xml_info_pkgs{$name}{description}; + } + header_non_available: + $description || N("No description"); +} + +sub packagesProviding { + my ($packages, $name) = @_; + grep { $_->is_arch_compat } URPM::packages_providing($packages, $name); +} + +#- search package with given name (and optional ISA) and compatible with current architecture. +#- take the best one found (most up-to-date). +# FIXME: reuse urpmi higher level code instead! +sub packageByName { + my ($packages, $name) = @_; + + my $basename = $name =~ s/\(x86-..\)$//r; + my @l = sort { $b->id <=> $a->id } grep { $_->name eq $basename } packagesProviding($packages, $name); + + my $best; + foreach (@l) { + if ($best && $best != $_) { + if ($best->fullname eq $_->fullname) { + $best = $_ if $_->flag_installed; + } else { + $_->compare_pkg($best) > 0 and $best = $_; + } + } else { + $best = $_; + } + } + $best or log::l("unknown package `$name'"); + $best; +} + +sub _is_kernelServer_needed() { + # forbid selecting kernel-server if not having PAE since PAE support is mandatory for kernel-server: + return if !detect_devices::has_cpu_flag('pae'); + arch() =~ /i.86/ && detect_devices::isServer(); +} + +sub _bestKernel_extensions { + my ($o_match_all_hardware) = @_; + + $::o->{kernel_extension} ? $::o->{kernel_extension} : + _is_kernelServer_needed() ? '-server' : + '-desktop'; +} + +sub bestKernelPackage { + my ($packages, $o_match_all_hardware) = @_; + + my @preferred_exts = _bestKernel_extensions($o_match_all_hardware); + my @kernels = grep { $_ } map { packageByName($packages, "kernel$_-latest") } @preferred_exts; + + if (!@kernels) { + #- fallback on most generic kernel if the suitable one is not available + my @fallback_exts = _bestKernel_extensions('force'); + @kernels = grep { $_ } map { packageByName($packages, "kernel$_-latest") } @fallback_exts; + } + + log::l("bestKernelPackage (" . join(':', @preferred_exts) . "): " . join(' ', map { $_->name } @kernels) . (@kernels > 1 ? ' (choosing the first)' : '')); + + $kernels[0]; +} + +sub packagesToInstall { + my ($packages) = @_; + my @packages; + foreach (@{$packages->{media}}) { + !$_->{ignore} or next; + log::l("examining packagesToInstall of medium $_->{name}"); + push @packages, grep { $_->flag_selected } install::media::packagesOfMedium($packages, $_); + } + log::l("found " . scalar(@packages) . " packages to install: " . formatList(5, map { scalar $_->fullname } @packages)); + + @packages; +} + +sub _packageRequest { + my ($packages, $pkg) = @_; + + #- check if the same or better version is installed, + #- do not select in such case. + $pkg && ($pkg->flag_upgrade || !$pkg->flag_installed) or return; + + #- check for medium selection, if the medium has not been + #- selected, the package cannot be selected. + my $medium = packageMedium($packages, $pkg); + $medium && !$medium->{ignore} or return; + + +{ $pkg->id => 1 }; +} + +sub packageCallbackChoices { + my ($urpm, $_db, $_state, $choices, $virtual_pkg_name, $prefered) = @_; + + if ($prefered && @$prefered) { + @$prefered; + } elsif (my @l = _packageCallbackChoices_($urpm, $choices, $virtual_pkg_name)) { + @l; + } else { + log::l("packageCallbackChoices: default choice ('" . $choices->[0]->name . "') from " . join(",", map { $_->name } @$choices) . " for $virtual_pkg_name"); + $choices->[0]; + } +} + +sub _packageCallbackChoices_ { + my ($urpm, $choices, $virtual_pkg_name) = @_; + + my ($prefer, $_other) = urpm::select::get_preferred($urpm, $choices, $::o->{preferred_packages}); + if (@$prefer) { + @$prefer; + } elsif ($virtual_pkg_name eq 'kernel') { + my $re = join('|', map { "kernel\Q$_-2" } _bestKernel_extensions()); + my @l = grep { $_->name =~ $re } @$choices; + log::l("packageCallbackChoices: kernel chosen ", join(",", map { $_->name } @l), " in ", join(",", map { $_->name } @$choices)); + @l; + } elsif ($choices->[0]->name =~ /^kernel-(.*source-|.*-devel-)/) { + my @l = grep { + if ($_->name =~ /^kernel-.*source-stripped-(.*)/) { + my $version = quotemeta($1); + find { + $_->name =~ /-$version$/ && ($_->flag_installed || $_->flag_selected); + } $urpm->packages_providing('kernel'); + } elsif ($_->name =~ /(kernel-.*)-devel-(.*)/) { + my $kernel = "$1-$2"; + my $p = packageByName($urpm, $kernel); + $p && ($p->flag_installed || $p->flag_selected); + } elsif ($_->name =~ /^kernel-.*source-/) { + #- hopefully we don't have a media with kernel-source but not kernel-source-stripped nor kernel-.*-devel + 0; + } else { + log::l("unknown kernel-source package " . $_->fullname); + 0; + } + } @$choices; + + log::l("packageCallbackChoices: kernel source chosen ", join(",", map { $_->name } @l), " in ", join(",", map { $_->name } @$choices)); + + @l; + } else { + (); + } +} + +sub skip_packages { + my ($packages, $skipped_packages) = @_; + $packages->compute_flags($skipped_packages, skip => 1); +} + +sub select_by_package_names { + my ($packages, $names, $b_base) = @_; + + my @l; + foreach (@$names) { + my $p = packageByName($packages, $_) or next; + push @l, selectPackage($packages, $p, $b_base); + } + @l; +} + +sub select_by_package_names_or_die { + my ($packages, $names, $b_base) = @_; + + foreach (@$names) { + my $p = packageByName($packages, $_) or die "package $_ not found"; + !$p->flag_installed && !$p->flag_selected or next; + my ($_pkgs, $error) = _selectPackage_with_error($packages, $p, $b_base); + $error and die N("Some packages requested by %s cannot be installed:\n%s", $_, $error); + } +} + +my @recommended_package_ids; +sub _resolve_requested_and_check { + my ($packages, $state, $requested) = @_; + + my @l = $packages->resolve_requested($packages->{rpmdb}, $state, $requested, + callback_choices => \&packageCallbackChoices, no_recommends => $::o->{no_recommends}); + + #- keep track of recommended packages so that theys could be unselected if the "no recommends" option is choosen later: + if (!is_empty_hash_ref($state->{selected})) { + my @new_ids = map { $packages->{depslist}[$_]->id } grep { $state->{selected}{$_}{recommended} } keys %{$state->{selected}}; + @recommended_package_ids = uniq(@recommended_package_ids, @new_ids); + } + + my $error; + if (find { !exists $state->{selected}{$_} } keys %$requested) { + my @rejected = urpm::select::unselected_packages($state); + $error = urpm::select::translate_why_unselected($packages, $state, @rejected); + log::l("ERROR: selection failed: $error"); + } + + \@l, $error; +} + +sub selectPackage { + my ($packages, $pkg, $b_base) = @_; + my ($pkgs, $_error) = _selectPackage_with_error($packages, $pkg, $b_base); + @$pkgs; +} + +sub _selectPackage_with_error { + my ($packages, $pkg, $b_base) = @_; + + my $state = $packages->{state} ||= {}; + + $packages->{rpmdb} ||= rpmDbOpen(); + + my ($pkgs, $error) = _resolve_requested_and_check($packages, $state, _packageRequest($packages, $pkg) || {}); + + if ($b_base) { + $_->set_flag_base foreach @$pkgs; + } + ($pkgs, $error); +} + +sub unselectPackage { + my ($packages, $pkg) = @_; + + #- base packages are not unselectable, + #- and already unselected package are no more unselectable. + $pkg->flag_base and return; + $pkg->flag_selected or return; + + my $state = $packages->{state} ||= {}; + log::l("removing selection on package " . $pkg->fullname); + my @l = $packages->disable_selected($packages->{rpmdb}, $state, $pkg); + log::l(" removed selection on package " . $pkg->fullname . "gives " . join(',', map { scalar $_->fullname } @l)); +} + +sub unselectAllPackages { + my ($packages) = @_; + my %keep_selected; + log::l("unselecting all packages..."); + foreach (@{$packages->{depslist}}) { + my $to_select = $_->flag_base || $_->flag_installed && $_->flag_selected; + # unselect recommended packages if minimal install: + if ($::o->{no_recommends} && member($_->id, @recommended_package_ids)) { + log::l("unselecting recommended package " . $_->name); + undef $to_select; + } + if ($to_select) { + #- keep track of packages that should be kept selected. + $keep_selected{$_->id} = $_; + } else { + #- deselect all packages except base or packages that need to be upgraded. + $_->set_flag_required(0); + $_->set_flag_requested(0); + } + } + #- clean state, in order to start with a brand new set... + $packages->{state} = {}; + _resolve_requested_and_check($packages, $packages->{state}, \%keep_selected); +} + + +my (@errors, $push_errors); +sub start_pushing_error() { + $push_errors = 1; + undef @errors; +} + +sub popup_errors() { + if (@errors) { + $::o->ask_warn(undef, N("An error occurred:") . "\n\n" . join("\n", @errors)); + } + undef $push_errors; +} + +sub empty_packages { + my ($o_keep_unrequested_dependencies) = @_; + my $packages = urpm->new; + urpm::get_global_options($packages); + urpm::set_files($packages, '/mnt'); + + #- add additional fields used by DrakX. + $packages->{media} = []; + + urpm::args::set_debug($packages) if $::o->{debug_urpmi}; + $packages->{log} = \&log::l; + $packages->{info} = \&log::l; + $packages->{fatal} = sub { + log::l("urpmi error: $_[1] ($_[0])\n" . common::backtrace()); + $::o->ask_warn(undef, N("A fatal error occurred: %s.", "$_[1] ($_[0])")); + }; + $packages->{error} = sub { + log::l("urpmi error: $_[0]"); + if ($push_errors) { + push @errors, @_; + return; + } + $::o->ask_warn(undef, N("An error occurred:") . "\n\n" . $_[0]); + }; + $packages->{root} = $::prefix; + $packages->{prefer_vendor_list} = '/etc/urpmi/prefer.vendor.list'; + $packages->{keep_unrequested_dependencies} = + defined($o_keep_unrequested_dependencies) ? $o_keep_unrequested_dependencies : 1; + $urpm::args::options{justdb} = $::o->{justdb}; + urpm::set_tune_rpm($packages, $::o->{'tune-rpm'}) if $::o->{'tune-rpm'}; + $::force = 1; + $packages->{options}{ignoresize} = 1; + $packages->{options}{retry} = 3; + $packages->{options}{downloader} = $::o->{options}{downloader}; + # prevent priority upgrade (redundant for now as $urpm->{root} implies disabling it: + $packages->{options}{'priority-upgrade'} = undef; + # log $trans->add() faillure; FIXME: should we override *urpm::msg::sys_log? + $packages->{debug} = $packages->{debug_URPM} = \&log::l; + $urpm::args::options{deploops} = $::o->{deploops}; + $packages->{options}{'curl-options'} = $::o->{curl_options} if $::o->{curl_options}; + + $packages; +} + +sub readCompssUsers { + my ($file) = @_; + + my $f = common::open_file($file) or log::l("cannot find $file: $!"), return; + my ($compssUsers, $gtk_display_compssUsers) = eval join('', <$f>); + if ($@) { + log::l("ERROR: bad $file: $@"); + } else { + log::l("compssUsers.pl got: ", join(', ', map { qq("$_->{path}|$_->{label}") } @$compssUsers)); + } + ($compssUsers, $gtk_display_compssUsers); +} + +sub saveCompssUsers { + my ($packages, $compssUsers) = @_; + my $flat; + foreach (@$compssUsers) { + my %fl = map { ("CAT_$_" => 1) } @{$_->{flags}}; + $flat .= "$_->{label} [icon=xxx] [path=$_->{path}]\n"; + foreach my $p (@{$packages->{depslist}}) { + my @flags = $p->rflags; + if ($p->rate && any { any { !/^!/ && $fl{$_} } split('\|\|') } @flags) { + $flat .= sprintf "\t%d %s\n", $p->rate, $p->name; + } + } + } + my $urpmidir = install::media::urpmidir(); + output "$urpmidir/compssUsers.flat", $flat; +} + +sub setSelectedFromCompssList { + my ($packages, $rpmsrate_flags_chosen, $min_level, $max_size) = @_; + $rpmsrate_flags_chosen->{TRUE} = 1; #- ensure TRUE is set + my $nb = selectedSize($packages); + + my %pkgs; + foreach my $p (@{$packages->{depslist}}) { + my @flags = $p->rflags; + next if + !$p->rate || $p->rate < $min_level || + any { !any { /^!(.*)/ ? !$rpmsrate_flags_chosen->{$1} : $rpmsrate_flags_chosen->{$_} } split('\|\|') } @flags; + $pkgs{$p->rate} ||= {}; + $pkgs{$p->rate}{$p->id} = 1 if _packageRequest($packages, $p); + } + my %pkgswanted; + foreach my $level (sort { $b <=> $a } keys %pkgs) { + #- determine the packages that will be selected + #- the packages are not selected. + my $state = $packages->{state} ||= {}; + foreach my $p (keys %{$pkgs{$level}}) { + $pkgswanted{$p} = 1; + } + my ($l, $_error) = _resolve_requested_and_check($packages, $state, \%pkgswanted); + + #- this enable an incremental total size. + my $old_nb = $nb; + foreach (@$l) { + $nb += $_->size; + } + if ($max_size && $nb > $max_size) { + log::l("disabling selected packages because too big for level $level: $nb > $max_size"); + $nb = $old_nb; + $min_level = $level; + $packages->disable_selected($packages->{rpmdb}, $state, @$l); + last; + } + } + my @flags = map_each { if_($::b, $::a) } %$rpmsrate_flags_chosen; + log::l("setSelectedFromCompssList: reached size ", int($nb / 1024/1024), "MB, up to indice $min_level (less than ", formatXiB($max_size), ") for flags ", join(' ', sort @flags)); + log::l("setSelectedFromCompssList: ", join(" ", sort map { $_->name } grep { $_->flag_selected } @{$packages->{depslist}})); + $min_level; +} + +#- useful to know the size it would take for a given min_level/max_size +#- just save the selected packages, call setSelectedFromCompssList, and restore the selected packages +sub saveSelected { + my ($packages) = @_; + my $state = delete $packages->{state}; + my @l = @{$packages->{depslist} || []}; + my @flags = map { ($_->flag_requested && 1) + ($_->flag_required && 2) + ($_->flag_upgrade && 4) } @l; + [ $packages, $state, \@l, \@flags ]; +} +sub restoreSelected { + my ($packages, $state, $l, $flags) = @{$_[0]}; + $packages->{state} = $state; + mapn { my ($pkg, $flag) = @_; + $pkg->set_flag_requested($flag & 1); + $pkg->set_flag_required($flag & 2); + $pkg->set_flag_upgrade($flag & 4); + } $l, $flags; +} + +sub _inside { + my ($l1, $l2) = @_; + my $i = 0; + return if @$l1 > @$l2; + foreach (@$l1) { + my $c; + while ($c = $l2->[$i++] cmp $_) { + return if $c == 1 || $i > @$l2; + } + } + 1; +} + +sub _or_ify { + my ($first, @other) = @_; + my @l = split('\|\|', $first); + foreach (@other) { + @l = map { + my $n = $_; + map { "$_&&$n" } @l; + } split('\|\|'); + } + @l; +} +sub _or_clean { + my ($flags) = @_; + my @l = split("\t", $flags); + @l = map { [ sort split('&&') ] } @l; + my @r; + B: while (@l) { + my $e = shift @l; + foreach (@r, @l) { + _inside($_, $e) and next B; + } + push @r, $e; + } + join("\t", map { join('&&', @$_) } @r); +} + + +sub computeGroupSize { + my ($packages, $min_level) = @_; + my (%group, %memo); + + my %or_ify_cache; + my $or_ify_cached = sub { + $or_ify_cache{$_[0]} ||= join("\t", _or_ify(split("\t", $_[0]))); + }; + + log::l("install::pkgs::computeGroupSize"); + my $time = time(); + + my %pkgs_with_same_rflags; + foreach (@{$packages->{depslist}}) { + next if !$_->rate || $_->rate < $min_level || $_->flag_available; + my $flags = join("\t", $_->rflags); + next if $flags eq 'FALSE'; + push @{$pkgs_with_same_rflags{$flags}}, $_; + } + + foreach my $raw_flags (keys %pkgs_with_same_rflags) { + my $flags = $or_ify_cached->($raw_flags); + my @pkgs = @{$pkgs_with_same_rflags{$raw_flags}}; + + #- determine the packages that will be selected when selecting $p. + #- make a fast selection (but potentially erroneous). + #- installed and upgrade flags must have been computed (see compute_installed_flags). + my %newSelection; + + my @l2 = map { $_->id } @pkgs; + my $id; + + while (defined($id = shift @l2)) { + exists $newSelection{$id} and next; + $newSelection{$id} = undef; + + my $pkg = $packages->{depslist}[$id]; + my @deps = map { [ $_, keys %{$packages->{provides}{$_} || {}} ] } $pkg->requires_nosense, $pkg->recommends_nosense; + foreach (sort { @$a <=> @$b } @deps) { #- sort on number of provides (it helps choosing "b" in: "a" requires both "b" and virtual={"b","c"}) + my ($virtual, @choices) = @$_; + if (@choices <= 1) { + #- only one choice :) + } elsif (find { exists $newSelection{$_} } @choices) { + @choices = (); + } else { + my @choices_pkgs = map { $packages->{depslist}[$_] } @choices; + if (find { $_->flag_available } @choices_pkgs) { + @choices = (); #- one package is already selected (?) + } else { + @choices = map { $_->id } packageCallbackChoices($packages, undef, undef, \@choices_pkgs, $virtual, undef); + } + } + push @l2, @choices; + } + } + + foreach (keys %newSelection) { + my $p = $packages->{depslist}[$_] or next; + next if $p->flag_selected; #- always installed (accounted in system_size) + my $s = $group{$p->name} || $or_ify_cached->(join("\t", $p->rflags)); + my $m = "$flags\t$s"; + $group{$p->name} = ($memo{$m} ||= _or_clean($m)); + } + } + my (%sizes, %pkgs); + while (my ($k, $v) = each %group) { + my $pkg = packageByName($packages, $k) or next; + push @{$pkgs{$v}}, $k; + $sizes{$v} += $pkg->size - $packages->{sizes}{$pkg->name}; + } + log::l("install::pkgs::computeGroupSize took: ", formatTimeRaw(time() - $time)); + log::l(sprintf "%s %dMB %s", $_, $sizes{$_} / sqr(1024), join(',', @{$pkgs{$_}})) foreach keys %sizes; + \%sizes, \%pkgs; +} + + +sub _openInstallLog() { + my $f = "$::prefix/root/drakx/install.log"; + open(my $LOG, ">> $f") ? log::l("opened $f") : log::l("Failed to open $f. No install log will be kept."); #-# + CORE::select((CORE::select($LOG), $| = 1)[0]); + URPM::rpmErrorWriteTo(fileno $LOG); + $LOG; +} + +sub _rebuild_RPM_DB() { + if (my $pid = fork()) { + waitpid $pid, 0; + $? & 0xff00 and die "rebuilding of rpm database failed"; + } else { + log::l("rebuilding rpm database"); + my $rebuilddb_dir = "$::prefix/var/lib/rpmrebuilddb.$$"; + if (-d $rebuilddb_dir) { + log::l("removing stale directory $rebuilddb_dir"); + rm_rf($rebuilddb_dir); + } + + if (!URPM::DB::rebuild($::prefix)) { + log::l("rebuilding of rpm database failed: " . URPM::rpmErrorString()); + c::_exit(2); + } + + c::_exit(0); + } +} + +sub rpmDbOpen { + my ($b_rebuild_if_needed) = @_; + + clean_rpmdb_shared_regions(); + + my $need_rebuild = $b_rebuild_if_needed && !URPM::DB::verify($::prefix); + + _rebuild_RPM_DB() if $need_rebuild; + + my $db; + if ($db = URPM::DB::open($::prefix)) { + log::l("opened rpm database for examining existing packages"); + } else { + log::l("unable to open rpm database, using empty rpm db emulation"); + $db = new URPM; + } + + $db; +} + +sub clean_rpmdb_shared_regions() { + unlink glob("$::prefix/var/lib/rpm/__db.*"); +} + +sub open_rpm_db_rw() { + clean_rpmdb_shared_regions(); + my $db = URPM::DB::open($::prefix, 1); + $db and log::l("opened rpmdb for writing in $::prefix"); + $db; +} + +sub cleanOldRpmDb() { + my $failed; + + foreach (qw(Basenames Conflictname Group Name Packages Providename Requirename Triggername)) { + -s "$::prefix/var/lib/rpm/$_" or $failed = 'failed'; + } + #- rebuilding has been successfull, so remove old rpm database if any. + #- once we have checked the rpm4 db file are present and not null, in case + #- of doubt, avoid removing them... + unless ($failed) { + log::l("rebuilding rpm database completed successfully"); + foreach (qw(conflictsindex.rpm fileindex.rpm groupindex.rpm nameindex.rpm packages.rpm + providesindex.rpm requiredby.rpm triggerindex.rpm)) { + -e "$::prefix/var/lib/rpm/$_" or next; + log::l("removing old rpm file $_"); + rm_rf("$::prefix/var/lib/rpm/$_"); + } + } +} + +sub selectPackagesAlreadyInstalled { + my ($packages) = @_; + + log::l("computing installed flags and size of installed packages"); + + $packages->compute_installed_flags($packages->{rpmdb}); + + my %sizes; + $packages->{rpmdb}->traverse(sub { + my ($p) = @_; + $sizes{$p->name} ||= 0; + $sizes{$p->name} += $p->size; + }); + $packages->{sizes} = \%sizes; +} + +sub selectPackagesToUpgrade { + my ($packages, $o_medium) = @_; + + log::l("selecting packages to upgrade"); + + my $state = $packages->{state} ||= {}; + $state->{selected} = {}; + + my %selection; + $packages->request_packages_to_upgrade($packages->{rpmdb}, $state, \%selection, + requested => undef, + $o_medium ? (start => $o_medium->{start}, end => $o_medium->{end}) : (), + ); + log::l("selected pkgs to upgrade: " . join(' ', map { $packages->{depslist}[$_]->name } keys %selection)); + + log::l("resolving dependencies..."); + _resolve_requested_and_check($packages, $state, \%selection); + log::l("...done"); + log::l("finally selected pkgs: ", join(" ", sort map { $_->name } grep { $_->flag_selected } @{$packages->{depslist}})); +} + +sub _filter_packages { + my ($retry, $packages, @packages) = @_; + grep { + if ($_->flag_installed || packageMedium($packages, $_)->{ignore}) { + if ($_->name eq 'mga-rpm-summary' && $_->flag_installed) { + install::pkgs::setup_rpm_summary_translations(); + } + $_->free_header; + 0; + } else { + log::l("failed to install " . $_->fullname . " (will retry)") if !$retry; + 1; + } + } @packages; +} + +sub install { + my ($isUpgrade, $toInstall, $packages, $callback) = @_; + my %packages; + + delete $packages->{rpmdb}; #- make sure rpmdb is closed before. + #- avoid potential problems with rpm db personality change + clean_rpmdb_shared_regions(); + + return if !@$toInstall; + + #- for root loopback'ed /boot + my $loop_boot = fs::loopback::prepare_boot(); + + #- first stage to extract some important information + #- about the selected packages. + my ($total, $nb) = (0, 0); + foreach my $pkg (@$toInstall) { + $packages{$pkg->id} = $pkg; + $nb++; + $total += $pkg->size; #- do not correct for upgrade! + } + + log::l("install::pkgs::install $::prefix"); + log::l("install::pkgs::install the following: ", join(" ", map { $_->name } values %packages)); + + URPM::read_config_files(); + # force loading libnss* + getgrent(); + URPM::add_macro(join(' ', '__dbi_other', URPM::expand('%__dbi_other'), 'nofsync')); + my $LOG = _openInstallLog(); + + $packages->{log} = $packages->{info} = $packages->{print} = sub { + print $LOG "$_[0]\n"; + }; + + #- do not modify/translate the message used with installCallback since + #- these are keys during progressing installation, or change in other + #- place (install::steps_gtk.pm,...). + $callback->($packages, user => undef, install => $nb, $total); + + my $exit_code = _install_raw($packages, $isUpgrade, $callback, $LOG, 0); + + log::l("closing install.log file"); + close $LOG; + + # prevent urpmi from trying to install them again (CHECKME: maybe uneeded): + $packages->{state} = {}; + + clean_rpmdb_shared_regions(); #- workaround librpm which is buggy when using librpm rooted and the just installed rooted library + + fs::loopback::save_boot($loop_boot); + + $exit_code; +} + +sub _unselect_package { + my ($packages, $pkg) = @_; + #- update flag associated to package. + $pkg->set_flag_installed(1); + $pkg->set_flag_upgrade(0); + #- update obsoleted entry. + my $rejected = $packages->{state}{rejected}; + foreach (keys %$rejected) { + if (delete $rejected->{$_}{closure}{$pkg->fullname}) { + %{$rejected->{$_}{closure}} or delete $rejected->{$_}; + } + } +} + +sub is_package_installed { + my ($db, $pkg) = @_; + my $check_installed; + $db->traverse_tag('name', [ $pkg->name ], sub { + my ($p) = @_; + $check_installed ||= $pkg->compare_pkg($p) == 0; + }); + return $check_installed; +} + +sub _install_raw { + my ($packages, $_isUpgrade, $callback, $LOG, $noscripts) = @_; + + # prevent warnings in install's logs: + local $ENV{LC_ALL} = 'C'; + + # let's be urpmi's compatible: + local $packages->{options}{noscripts} = $noscripts; + # leaks a fd per transaction (around ~100 for a typically gnome install, see #49097): + # bug present in 2009.0, 2008.1, 2008.0, ... (probably since r11141 aka when switching to rpm-4.2 in URPM-0.83) + local $packages->{options}{script_fd} = fileno $LOG; + + start_pushing_error(); + + log::l("rpm transactions start"); + + my ($is_installing, $verify_just_closed); + my $exit_code = urpm::main_loop::run($packages, $packages->{state}, undef, undef, { + open_helper => sub { + &$callback; + $is_installing = 0; + }, + verify => $callback, + close_helper => sub { + my ($db, $packages, $_type, $id) = @_; + &$callback; + return if !$is_installing; # don't check if it's installed if it's being verified + my $pkg = defined $id && $packages->{depslist}[$id] or return; + print $LOG $pkg->fullname . "\n"; + my $check_installed = is_package_installed($db, $pkg); + if ($pkg->name eq 'mga-rpm-summary' && $check_installed) { + install::pkgs::setup_rpm_summary_translations(); + } + + if ($check_installed) { + _unselect_package($packages, $pkg); + } else { + log::l($pkg->name . " not installed, " . URPM::rpmErrorString()); + } + }, + inst => sub { + &$callback; + $is_installing = 1; + }, + trans => $callback, + # FIXME: implement already_installed_or_not_installable + bad_signature => sub { + my ($msg, $msg2) = @_; + $msg =~ s/:$/\n\n/m; # FIXME: to be fixed in urpmi after 2008.0 (sic!) + log::l($msg); + log::l($msg2); + return 0 if $packages->{options}{auto}; + state $do_not_ask; + state $answer; + return $answer if $do_not_ask; + $answer = $::o->ask_from_({ messages => "$msg\n\n$msg2" }, [ + { val => \$do_not_ask, + type => 'bool', text => N("Do not ask again"), + }, + ]); + }, + copy_removable => sub { + my ($medium) = @_; + $::o->ask_change_cd($medium); + }, + is_canceled => sub { + return $install::pkgs::cancel_install; + }, + trans_error_summary => sub { + my ($nok, $errors) = @_; + log::l($nok . " installation transactions failed"); + log::l(join("\n", @$errors)); + if (!$packages->{options}{auto}) { + $::o->ask_warn(N("Error"), N("%d installation transactions failed", $nok) . "\n\n" . + N("Installation of packages failed:") . "\n\n" . join("\n", @$errors)); + } + }, + completed => sub { + if (!$packages->{options}{auto}) { + popup_errors(); + } + }, + message => sub { + my ($title, $message) = @_; + log::l($message); + $::o->ask_warn($title, $message); + }, + ask_yes_or_no => sub { + my ($title, $msg) = @_; + log::l($msg); + $::o->ask_yesorno($title, $msg); + }, + ask_for_bad_or_missing => sub { + my ($_title, $msg) = @_; + log::l($msg); + state $do_not_ask; + state $answer; + return $answer if $do_not_ask; + $answer = $::o->ask_from_({ messages => $msg }, [ + { val => \$do_not_ask, type => 'bool', text => N("Do not ask again"), + }, + ]); + }, + # Uneeded callbacks: success_summary + }); + + log::l("transactions done, now trying to close still opened fd; exit code=$exit_code"); + + $exit_code; +} + +sub upgrade_by_removing_pkgs { + my ($packages, $callback, $extension, $upgrade_name) = @_; + + my $upgrade_data; + if ($upgrade_name) { + my @l = glob("$ENV{SHARE_PATH}/upgrade/$upgrade_name*"); + @l == 0 and log::l("upgrade_by_removing_pkgs: no special upgrade data"); + @l > 1 and log::l("upgrade_by_removing_pkgs: many special upgrade data (" . join(' ', @l) . ")"); + $upgrade_data = $l[0]; + } + + log::l("upgrade_by_removing_pkgs (extension=$extension, upgrade_data=$upgrade_data)"); + + #- put the release file in /root/drakx so that we continue an upgrade even if the file has gone + my $f = common::release_file($::prefix); + if (dirname($f) eq '/etc') { + output_p("$::prefix/root/drakx/" . basename($f) . '.upgrading', cat_("$::prefix$f")); + } + my $busy_var_tmp = "$::prefix/var/tmp/ensure-rpm-does-not-remove-this-dir"; + touch($busy_var_tmp); + + if ($upgrade_data) { + foreach (glob("$upgrade_data/pre.*")) { + my $f = '/tmp/' . basename($_); + cp_af($_, "$::prefix$f"); + run_program::rooted($::prefix, $f); + unlink "$::prefix$f"; + } + } + + my @was_installed = _remove_pkgs_to_upgrade($packages, $callback, $extension); + + { + my @restore_files = qw(/etc/passwd /etc/group /etc/ld.so.conf); + foreach (@restore_files) { + rename "$::prefix$_.rpmsave", "$::prefix$_"; + } + fs::any::create_minimal_files(); + unlink $busy_var_tmp; + } + + my %map = map { + chomp; + my ($name, @new) = split; + $name => \@new; + } $upgrade_data ? cat_("$upgrade_data/map") : (); + + log::l("upgrade_by_removing_pkgs: map $upgrade_data/map gave " . (int keys %map) . " rules"); + + my $log; + my @to_install = uniq(map { + $log .= " $_=>" . join('+', @{$map{$_}}) if $map{$_}; + $map{$_} ? @{$map{$_}} : $_; + } @was_installed); + log::l("upgrade_by_removing_pkgs special maps:$log"); + log::l("upgrade_by_removing_pkgs: wanted packages: ", join(' ', sort @to_install)); + + @to_install; +} + +sub removed_pkgs_to_upgrade_file() { "$::prefix/root/drakx/removed_pkgs_to_upgrade" } + +sub _remove_pkgs_to_upgrade { + my ($packages, $callback, $extension) = @_; + + my @to_remove; + my @was_installed; + { + $packages->{rpmdb} ||= rpmDbOpen(); + $packages->{rpmdb}->traverse(sub { + my ($pkg) = @_; + if ($pkg->release =~ /$extension$/) { + push @was_installed, $pkg->name; + push @to_remove, scalar $pkg->fullname; + } + }); + } + if (-e removed_pkgs_to_upgrade_file()) { + log::l("removed_pkgs_to_upgrade: using saved installed packages list ", removed_pkgs_to_upgrade_file()); + @was_installed = chomp_(cat_(removed_pkgs_to_upgrade_file())); + } else { + log::l("removed_pkgs_to_upgrade: saving (old) installed packages in ", removed_pkgs_to_upgrade_file()); + output_p(removed_pkgs_to_upgrade_file(), map { "$_\n" } @was_installed); + } + + delete $packages->{rpmdb}; #- make sure rpmdb is closed before. + + _remove(\@to_remove, $callback, noscripts => 1); + + @was_installed; +} + +sub remove_marked_ask_remove { + my ($packages, $callback) = @_; + + my @to_remove = keys %{$packages->{state}{ask_remove}} or return; + + delete $packages->{rpmdb}; #- make sure rpmdb is closed before. + + #- we are not checking depends since it should come when + #- upgrading a system. although we may remove some functionalities ? + + _remove(\@to_remove, $callback, force => 1); + + delete $packages->{state}{ask_remove}{$_} foreach @to_remove; +} + +sub _remove_raw { + my ($to_remove, $callback, %run_transaction_options) = @_; + + log::l("removing: " . join(' ', @$to_remove)); + + URPM::read_config_files(); + URPM::add_macro(URPM::expand('__dbi_other %__dbi_other nofsync')); + + my $db = open_rpm_db_rw() or die "error opening RPM database: ", URPM::rpmErrorString(); + my $trans = $db->create_transaction; + + #- stuff remove all packages that matches $p, not a problem since $p has name-version-release format. + $trans->remove($_) foreach @$to_remove; + + $callback->($db, user => undef, remove => scalar @$to_remove); + + $trans->run(undef, %run_transaction_options, callback_uninst => $callback); +} +sub _remove { + my ($_to_remove, $_callback, %run_transaction_options) = @_; + + my @pbs = &_remove_raw; + if (@pbs && !$run_transaction_options{noscripts}) { + $run_transaction_options{noscripts} = 1; + @pbs = &_remove_raw; + } + if (@pbs) { + die "removing of old rpms failed:\n ", join("\n ", @pbs); + } +} + +sub setup_rpm_summary_translations() { + my @domains = qw(rpm-summary-contrib rpm-summary-devel rpm-summary-main); + push @::textdomains, @domains; + foreach (@domains) { + Locale::gettext::bind_textdomain_codeset($_, 'UTF-8'); + Locale::gettext::bindtextdomain($_, "$::prefix/usr/share/locale"); + } +} + +sub selected_leaves { + my ($packages) = @_; + my $provides = $packages->{provides}; + + my @l = grep { $_->flag_requested || $_->flag_installed } @{$packages->{depslist}}; + + my %required_ids; + foreach my $pkg (@l) { + foreach my $req ($pkg->requires_nosense) { + my $h = $provides->{$req} or next; + my @provides = my ($provide) = keys %$h; + @provides == 1 or next; + if ($provide != (exists $required_ids{$pkg->id} ? $required_ids{$pkg->id} : $pkg->id)) { +# log::l($packages->{depslist}[$provide]->name . " is not a leaf because required by " . $pkg->name . " (through require $req)"); + #- $pkg requires $req, provided by $provide, so we can skip $provide + $required_ids{$provide} = $pkg->id; + } + } + } + [ map { $_->name } grep { ! exists $required_ids{$_->id} } @l ]; +} + +1; |