diff options
Diffstat (limited to 'URPM')
| -rw-r--r-- | URPM/Resolve.pm | 354 |
1 files changed, 255 insertions, 99 deletions
diff --git a/URPM/Resolve.pm b/URPM/Resolve.pm index e13cc23..7b63be2 100644 --- a/URPM/Resolve.pm +++ b/URPM/Resolve.pm @@ -2,6 +2,82 @@ package URPM; use strict; +#- find candidates packages from a require string (or id), +#- take care of direct choices using | sepatator. +sub find_candidate_packages { + my ($urpm, $dep) = @_; + my %packages; + + foreach (split '\|', $dep) { + if (/^\d+$/) { + my $pkg = $urpm->{depslist}[$_]; + $pkg->arch eq 'src' || $pkg->is_arch_compat or next; + push @{$packages{$pkg->name}}, $pkg; + } elsif (my ($property, $name) = /^(([^\s\[]*).*)/) { + foreach (keys %{$urpm->{provides}{$name} || {}}) { + my $pkg = $urpm->{depslist}[$_]; + $pkg->is_arch_compat or next; + #- check if at least one provide of the package overlap the property. + my $satisfied = 0; + foreach ($pkg->provides) { + ranges_overlap($property, $_) and ++$satisfied, last; + } + $satisfied and push @{$packages{$pkg->name}}, $pkg; + } + } + } + \%packages; +} + +#- return unresolved requires of a package (a new one or a existing one). +sub unsatisfied_requires { + my ($urpm, $db, $state, $pkg, $name) = @_; + my %properties; + + #- all requires should be satisfied according to selected package, or installed packages. + foreach ($pkg->requires) { + if (my ($n, $s) = /^([^\s\[]*)(?:\[\*\])?\[?([^\s\]]*\s*[^\s\]]*)/) { + #- allow filtering on a given name (to speed up some search). + ! defined $name || $n eq $s or next; + + #- avoid recomputing the same all the time. + exists $properties{$_} || $state->{installed}{$_} and next; + + #- keep track if satisfied. + my $satisfied = 0; + #- check on selected package if a provide is satisfying the resolution (need to do the ops). + foreach my $sense (keys %{$state->{provided}{$n} || {}}) { + ranges_overlap($sense, $s) and ++$satisfied, last; + } + #- check on installed system a package which is not obsoleted is satisfying the require. + unless ($satisfied) { + if ($n =~ /^\//) { + $db->traverse_tag('path', [ $n ], sub { + my ($p) = @_; + exists $state->{obsoleted}{$p->fullname} and return; + ++$satisfied; + }); + } else { + $db->traverse_tag('whatprovides', [ $n ], sub { + my ($p) = @_; + exists $state->{obsoleted}{$p->fullname} and return; + foreach ($p->provides) { + $state->{installed}{$_}{$p->fullname} = undef; + if (my ($pn, $ps) = /^([^\s\[]*)(?:\[\*\])?\[?([^\s\]]*\s*[^\s\]]*)/) { + $pn eq $n or next; + ranges_overlap($ps, $s) and ++$satisfied; + } + } + }); + } + } + #- if nothing can be done, the require should be resolved. + $satisfied or $properties{$_} = undef; + } + } + keys %properties; +} + #- resolve requested, keep resolution state to speed process. #- a requested package is marked to be installed, once done, a upgrade flag or #- installed flag is set according to needs of package. @@ -19,76 +95,61 @@ sub resolve_requested { #- package present or by a new package to upgrade), then requires not satisfied and #- finally conflicts that will force a new upgrade or a remove. @properties = keys %{$state->{requested}}; - @requested{map { split '\|', $_ } @properties} = (); - while (defined ($dep = shift @properties)) { - my ($allow_src, %packages, @chosen_requested, @chosen_upgrade, @chosen, %diff_provides, $pkg); + foreach my $dep (@properties) { foreach (split '\|', $dep) { - if (/^\d+$/) { - my $pkg = $urpm->{depslist}[$_]; - $allow_src = 1; - push @{$packages{$pkg->name}}, $pkg; - } elsif (my ($property, $name) = /^(([^\s\[]*).*)/) { - foreach (keys %{$urpm->{provides}{$name} || {}}) { - my $pkg = $urpm->{depslist}[$_]; - my $satisfied = 0; - #- check if at least one provide of the package overlap the property. - foreach ($pkg->provides) { - ranges_overlap($property, $_) and ++$satisfied, last; - } - $satisfied and push @{$packages{$pkg->name}}, $pkg; - } - } + $requested{$_} = $state->{requested}{$dep}; } + } + while (defined ($dep = shift @properties)) { + my (@chosen_requested, @chosen_upgrade, @chosen, %diff_provides, $pkg); #- take the best package for each choices of same name. - foreach (values %packages) { + my $packages = $urpm->find_candidate_packages($dep); + foreach (values %$packages) { my $best; foreach (@$_) { - if (defined $allow_src && $_->arch eq 'src' || $_->is_arch_compat) { - if ($best && $best != $_) { - $_->compare_pkg($best) > 0 and $best = $_; - } else { - $best = $_; - } + if ($best && $best != $_) { + $_->compare_pkg($best) > 0 and $best = $_; + } else { + $best = $_; } } $_ = $best; } - if (keys %packages > 1) { + if (keys(%$packages) > 1) { #- package should be prefered if one of their provides is referenced #- in requested hash or package itself is requested (or required). #- if there is no preference choose the first one (higher probability #- of being chosen) by default and ask user. - foreach my $pkg (values %packages) { - $pkg or next; #- this could happen if no package are suitable for this arch. - if (exists $requested{$pkg->id}) { - push @chosen_requested, $pkg; - } elsif ($db->traverse_tag('name', [ $pkg->name ], undef) > 0) { - push @chosen_upgrade, $pkg; + foreach my $p (values %$packages) { + $p or next; #- this could happen if no package are suitable for this arch. + exists $state->{selected}{$p->id} and $pkg = $p, last; #- already selected package is taken. + if (exists $requested{$p->id}) { + push @chosen_requested, $p; + } elsif ($db->traverse_tag('name', [ $p->name ], undef) > 0) { + push @chosen_upgrade, $p; } else { - push @chosen, $pkg; + push @chosen, $p; } } @chosen_requested > 0 and @chosen = @chosen_requested; @chosen_requested == 0 and @chosen_upgrade > 0 and @chosen = @chosen_upgrade; } else { - @chosen = values %packages; + @chosen = values %$packages; } - if (@chosen > 1) { - #- solve choices by asking user. - print STDERR "asking user for ".scalar(@chosen)." choices\n"; - #TODO + if (!$pkg && $options{callback_choices} && @chosen > 1) { + $pkg ||= $options{callback_choices}->($urpm, $db, $state, \@chosen); } $pkg ||= $chosen[0]; $pkg && !$pkg->flag_requested && !$pkg->flag_required or next; #- keep in mind the package has be selected. - $pkg->set_flag_requested(exists $requested{$dep}); - $pkg->set_flag_required(! exists $requested{$dep}); + $pkg->set_flag_requested($state->{selected}{$pkg->id} = delete $requested{$dep}); + $pkg->set_flag_required(!$pkg->flag_requested); #- check if package is not already installed before trying to use it, compute #- obsoleted package too. this is valable only for non source package. if ($pkg->arch ne 'src') { - $pkg->flag_installed and next; + $pkg->flag_installed and delete $state->{selected}{$pkg->id}, next; unless ($pkg->flag_upgrade) { $db->traverse_tag('name', [ $pkg->name ], sub { my ($p) = @_; @@ -97,35 +158,34 @@ sub resolve_requested { }); $pkg->set_flag_upgrade(!$pkg->flag_installed); } - $pkg->flag_installed and next; + $pkg->flag_installed and delete $state->{selected}{$pkg->id}, next; #- keep in mind the provides of this package, so that future requires can be satisfied #- with this package potentially. foreach ($pkg->provides) { - $state->{provided}{$_}{$pkg->id} = undef; + if (my ($n, $s) = /^([^\s\[]*)(?:\[\*\])?\[?([^\s\]]*\s*[^\s\]]*)/) { + $state->{provided}{$n}{$s}{$pkg->id} = undef; + } } foreach ($pkg->name, $pkg->obsoletes) { if (my ($n, $o, $v) = /^([^\s\[]*)(?:\[\*\])?\[?([^\s\]]*)\s*([^\s\]]*)/) { $db->traverse_tag('name', [ $n ], sub { my ($p) = @_; - eval($p->compare($v) . $o . 0) or return; + !$o || eval($p->compare($v) . $o . 0) or return; $state->{obsoleted}{$p->fullname}{$pkg->id} = undef; foreach ($p->provides) { - #- check if a installed property has been required which needs to be - #- re-evaluated to solve this one. - if (my $ip = $state->{installed}{$_}) { - if (exists $ip->{$p->fullname} && keys(%$ip) == 1) { - push @properties, $n; - delete $state->{installed}{$_}; - } else { - delete $ip->{$p->fullname}; - } + #- clean installed property. + if (my ($ip) = $state->{installed}{$_}) { + delete $ip->{$p->fullname}; + %$ip or delete $state->{installed}{$_}; } #- check differential provides between obsoleted package and newer one. - $state->{provided}{$_} or $diff_provides{$n} = undef; + if (my ($pn, $ps) = /^([^\s\[]*)(?:\[\*\])?\[?([^\s\]]*\s*[^\s\]]*)/) { + ($state->{provided}{$pn} || {})->{$ps} or $diff_provides{$n} = undef; + } } }); } @@ -134,66 +194,162 @@ sub resolve_requested { foreach my $n (keys %diff_provides) { $db->traverse_tag('whatrequires', [ $n ], sub { my ($p) = @_; - my ($needed, $satisfied) = (0, 0); - foreach ($p->requires) { - if (my ($pn, $o, $v) = /^([^\[]*)(?:\[\*\])?\[?([^\s\]]*)\s*([^\s\]]*)/) { - if ($o) { - $pn eq $n && $pn eq $pkg->name or next; - ++$needed; - eval($pkg->compare($v) . $o . 0) or next; - #- an existing provides (propably the one examined) is satisfying. - ++$satisfied; + if (my @l = $urpm->unsatisfied_requires($db, $state, $p)) { + #- try if upgrading the package will be satisfying all the requires + #- else it will be necessary to ask hte user for removing it. + my $packages = $urpm->find_candidate_packages($p->name); + my $best; + foreach (grep { $urpm->unsatisfied_requires($db, $state, $_, $n) == 0 } + @{$packages->{$p->name}}) { + if ($best && $best != $_) { + $_->compare_pkg($best) > 0 and $best = $_; } else { - $pn eq $n && $pn ne $pkg->name or next; - #- a property has been removed since in diff_provides. - ++$needed; + $best = $_; } } - } - #- check if the package need to be updated because it - #- losts some of its requires regarding the current diff_provides. - if ($needed > $satisfied) { - push @properties, $p->name; + if ($best) { + push @properties, $best->id; + } else { + #- no package have been found, we need to remove the package examined. + push @{$state->{ask_remove}{$p->fullname}}, { unsatisfied => \@l, pkg => $pkg }; + } } }); } } #- all requires should be satisfied according to selected package, or installed packages. - foreach ($pkg->requires) { - $state->{provided}{$_} || $state->{installed}{$_} and next; - #- keep track if satisfied. - my $satisfied = 0; - #- check on selected package if a provide is satisfying the resolution (need to do the ops). - foreach my $provide (keys %{$state->{provided}}) { - ranges_overlap($provide, $_) and ++$satisfied, last; - } - #- check on installed system a package which is not obsoleted is satisfying the require. - unless ($satisfied) { - if (my ($file) = /^(\/[^\s\[]*)/) { - $db->traverse_tag('path', [ $file ], sub { - my ($p) = @_; - exists $state->{obsoleted}{$p->fullname} and return; - ++$satisfied; - }); - } elsif (my ($property, $name) = /^(([^\s\[]*).*)/) { - $db->traverse_tag('whatprovides', [ $name ], sub { - my ($p) = @_; - exists $state->{obsoleted}{$p->fullname} and return; - foreach ($p->provides) { - $state->{installed}{$_}{$p->fullname} = undef; - ranges_overlap($_, $property) and ++$satisfied, return; + push @properties, $urpm->unsatisfied_requires($db, $state, $pkg); + + #- examine conflicts, an existing package conflicting with this selection should + #- be upgraded to a new version which will be safe, else it should be removed. + foreach ($pkg->conflicts) { + if (my ($file) = /^(\/[^\s\[]*)/) { + $db->traverse_tag('path', [ $file ], sub { + my ($p) = @_; + $state->{conflicts}{$p->fullname}{$pkg->id} = undef; + #- all these packages should be removed. + push @{$state->{ask_remove}{$p->fullname}}, { conflicts => $file, pkg => $pkg }; + }); + } elsif (my ($property, $name) = /^(([^\s\[]*).*)/) { + $db->traverse_tag('whatprovides', [ $name ], sub { + my ($p) = @_; + if (grep { ranges_overlap($_, $property) } $p->provides) { + #- the existing package will conflicts with selection, check if a newer + #- version will be ok, else ask to remove the old. + my $packages = $urpm->find_candidate_packages($p->name); + my $best; + foreach (@{$packages->{$p->name}}) { + unless (grep { ranges_overlap($_, $property) } $_->provides) { + if ($best && $best != $_) { + $_->compare_pkg($best) > 0 and $best = $_; + } else { + $best = $_; + } + } } - }); + if ($best) { + push @properties, $best->id; + } else { + #- no package have been found, we need to remove the package examined. + push @{$state->{ask_remove}{$p->fullname}}, { conflicts => $property, pkg => $pkg }; + } + } + }); + } + #- we need to check a selected package is not selected. + #- if true, it should be unselected. + if (my ($name) =~ /^([^\s\[]*)/) { + foreach (keys %{$urpm->{provides}{$name} || {}}) { + my $p = $urpm->{depslist}[$_]; + ($pkg->flag_requested || $pkg->flag_required) && $pkg->flag_upgrade and + $state->{ask_unselect}{$p->id}{$pkg->id}; } } - #- if nothing can be done, the require should be resolved. - $satisfied or push @properties, $_; } + } + + #- obsoleted packages are no longer marked as being asked to be removed. + delete @{$state->{ask_remove}}{keys %{$state->{obsoleted}}}; +} - #- examine conflicts. - #TODO +#- select packages to upgrade, according to package already registered. +#- by default, only takes best package and its obsoleted and compute +#- all installed or upgrade flag. +sub resolve_packages_to_upgrade { + my ($urpm, $db, $state, %options) = @_; + my (%names, %skip, %obsoletes); + + #- build direct access to best package according to name. + foreach (@{$urpm->{depslist}}) { + if ($_->is_arch_compat) { + my $p = $names{$_->name}; + if ($p) { + if ($_->compare_pkg($p) > 0) { + $names{$_->name} = $_; + } + } else { + $names{$_->name} = $_; + } + } } + + #- check consistency with obsoletes of eligible package. + #- it is important not to select a package wich obsolete + #- an old one. + foreach my $pkg (values %names) { + foreach ($pkg->obsoletes) { + if (my ($n, $o, $v) = /^([^\s\[]*)(?:\[\*\])?\[?([^\s\]]*)\s*([^\s\]]*)/) { + if ($names{$n} && (!$o || eval($names{$n}->compare($v) . $o . 0))) { + #- an existing best package is obsoleted by another one. + $skip{$n} = undef; + } + push @{$obsoletes{$n}}, $pkg; + } + } + } + + #- now we can examine all existing packages to find packages to upgrade. + $db->traverse(sub { + my ($p) = @_; + #- first try with package using the same name. + #- this will avoid selecting all packages obsoleting an old one. + if (my $pkg = $names{$p->name}) { + if ($pkg->compare_pkg($p) <= 0) { + #- this means the package is already installed (or there + #- is a old version in depslist). + $pkg->set_flag_installed(1); + $pkg->set_flag_upgrade(0); + } else { + #- the depslist version is better than existing one. + $pkg->set_flag_installed(0); + $pkg->set_flag_upgrade(1); + $state->{requested}{$pkg->id} = $options{requested}; + return; + } + } + + #- check provides of existing package to see if a obsolete + #- may allow selecting it. + foreach ($p->provides) { + if (my ($n) = /^([^\s\[]*)/) { + foreach my $pkg (@{$obsoletes{$n} || []}) { + next if $pkg->name eq $p->name; + foreach my $property ($pkg->obsoletes) { + if (ranges_overlap($property, $_)) { + #- the package being examined can be obsoleted. + #- do not set installed and provides flags. + $state->{requested}{$pkg->id} = $options{requested}; + return; + } + } + } + } + } + }); + + #TODO is conflicts for selection of package, it is important to choose + #TODO right package to install. } 1; |