urpm/orphans.pm

filter: Statementstmt 77.7% 7 / 9 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 3 / 3 Podpod n/a totaltotal 83.3% 10 / 12 CC 1 SCAR 0.9
CC
1
Cov
78%
BEGIN
1.3
BEGIN
1.0
BEGIN
1.0
CRAP 1.1
« urpm/mirrors.pm ↑ Summary urpm/parallel_ka_run.pm »
1 package urpm::orphans;
2  
3 1 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 1 ▶use urpm::util qw(add2hash_ append_to_file cat_ member output_safe partition put_in_hash uniq wc_l);
Subroutine BEGIN: called CC=1 SCAR=0.0
5 0 ▶use urpm::msg;
Subroutine BEGIN: called CC=1 SCAR=2.6
6 use urpm;
7  
8  
9 my $fullname2name_re = qr/^(.*)-[^\-]*-[^\-]*\.[^\.\-]*$/;
10  
11  
12 =head1 NAME
13  
14 urpm::orphans - The orphan management code for urpmi
15  
16 =head1 SYNOPSIS
17  
18 =head1 DESCRIPTION
19  
20 =over
21  
22 =cut
23  
24 #- side-effects: none
25 sub installed_packages_packed {
26 my ($urpm) = @_;
27  
28 my $db = urpm::db_open_or_die_($urpm);
29 my @l;
30 $db->traverse(sub {
31 my ($pkg) = @_;
32 $pkg->pack_header;
33 push @l, $pkg;
34 });
35 \@l;
36 }
37  
38  
39 =item unrequested_list__file($urpm)
40  
41 Return the path of the unrequested list file.
42  
43 =cut
44  
45 #- side-effects: none
46 sub unrequested_list__file {
47 my ($urpm) = @_;
48 ($urpm->{env_dir} || "$urpm->{root}/var/lib/rpm") . '/installed-through-deps.list';
49 }
50  
51 =item unrequested_list($urpm)
52  
53 Returns the list of potentiel files (ake files installed as requires for others)
54  
55 =cut
56  
57 #- side-effects: none
58 sub unrequested_list {
59 my ($urpm) = @_;
60 +{ map {
61 chomp;
62 s/\s+\(.*\)$//;
63 $_ => 1;
64 } cat_(unrequested_list__file($urpm)) };
65 }
66  
67 =item mark_as_requested($urpm, $state, $test)
68  
69 Mark some packages as explicitly requested (usually because
70 they were manually installed).
71  
72 =cut
73  
74 #- side-effects: those of _write_unrequested_list__file
75 sub mark_as_requested {
76 my ($urpm, $state, $test) = @_;
77 my $unrequested = unrequested_list($urpm);
78 my $dirty;
79  
80 foreach (keys %{$state->{rejected_already_installed}},
81 grep { $state->{selected}{$_}{requested} } keys %{$state->{selected}}) {
82 my $name = $urpm->{depslist}[$_]->name;
83 if (defined($unrequested->{$name})) {
84 $urpm->{info}(N("Marking %s as manually installed, it won't be auto-orphaned", $name));
85 $dirty = 1;
86 } else {
87 $urpm->{debug}("$name is not in potential orphans") if $urpm->{debug};
88 }
89 delete $unrequested->{$name};
90 }
91  
92 if ($dirty && !$test) {
93 _write_unrequested_list__file($urpm, [keys %$unrequested]);
94 }
95 }
96  
97 =item _installed_req_and_unreq($urpm)
98  
99 Returns :
100  
101 =over
102  
103 =item * req: list of installed packages that were installed as requires of others
104  
105 =item * unreq: list of installed packages that were not installed as requres of others (ie the ones that were explicitely selected for install)
106  
107 =back
108  
109 =cut
110  
111 #- side-effects:
112 #- + those of _installed_req_and_unreq_and_update_unrequested_list (<root>/var/lib/rpm/installed-through-deps.list)
113 sub _installed_req_and_unreq {
114 my ($urpm) = @_;
115 my ($req, $unreq, $_unrequested) = _installed_req_and_unreq_and_update_unrequested_list($urpm);
116 ($req, $unreq);
117 }
118  
119 =item _installed_and_unrequested_lists($urpm)
120  
121 Returns :
122  
123 =over
124  
125 =item * pkgs: list of installed packages
126  
127 =item * unrequested: list of packages that were installed as requires of others (the sum of the previous lists)
128  
129 =back
130  
131 =cut
132  
133 #- side-effects:
134 #- + those of _installed_req_and_unreq_and_update_unrequested_list (<root>/var/lib/rpm/installed-through-deps.list)
135 sub _installed_and_unrequested_lists {
136 my ($urpm) = @_;
137 my ($pkgs, $pkgs2, $unrequested) = _installed_req_and_unreq_and_update_unrequested_list($urpm);
138 push @$pkgs, @$pkgs2;
139 ($pkgs, $unrequested);
140 }
141  
142 #- side-effects: <root>/var/lib/rpm/installed-through-deps.list
143 sub _write_unrequested_list__file {
144 my ($urpm, $unreq) = @_;
145 return if $>;
146  
147 $urpm->{info}("writing " . unrequested_list__file($urpm));
148
149 output_safe(unrequested_list__file($urpm),
150 join('', sort map { $_ . "\n" } @$unreq),
151 ".old") if !$urpm->{env_dir};
152 }
153  
154 =item _installed_req_and_unreq_and_update_unrequested_list ($urpm)
155  
156 Returns :
157  
158 =over
159  
160 =item * req: list of installed packages that were installed as requires of others
161  
162 =item * unreq: list of installed packages that were not installed as requres of others (ie the ones that were explicitely selected for install)
163  
164 =item * unrequested: list of packages that were installed as requires of others (the sum of the previous lists)
165  
166 =back
167  
168 =cut
169  
170 #- side-effects: those of _write_unrequested_list__file
171 sub _installed_req_and_unreq_and_update_unrequested_list {
172 my ($urpm) = @_;
173  
174 my $pkgs = installed_packages_packed($urpm);
175  
176 $urpm->{debug}("reading and cleaning " . unrequested_list__file($urpm)) if $urpm->{debug};
177 my $unrequested = unrequested_list($urpm);
178 my ($unreq, $req) = partition { $unrequested->{$_->name} } @$pkgs;
179
180 # update the list (to filter dups and now-removed-pkgs)
181 my @old = keys %$unrequested;
182 my @new = map { $_->name } @$unreq;
183 if (@new != @old) {
184 _write_unrequested_list__file($urpm, \@new);
185 }
186  
187 ($req, $unreq, $unrequested);
188 }
189  
190 =item _selected_unrequested($urpm, $selected, $rejected)
191  
192 Returns the new "unrequested" packages.
193 The reason can be "required by xxx" or "recommended"
194  
195 =cut
196  
197 #- side-effects: none
198 sub _selected_unrequested {
199 my ($urpm, $selected, $rejected) = @_;
200  
201 require urpm::select;
202 map {
203 if (my $from = $selected->{$_}{from}) {
204 my $pkg = $urpm->{depslist}[$_];
205 my $name = $pkg->name;
206 $pkg->flag_requested || urpm::select::was_pkg_name_installed($rejected, $name) ? () :
207 ($name => "(required by " . $from->fullname . ")");
208 } elsif ($selected->{$_}{recommended}) {
209 ($urpm->{depslist}[$_]->name => "(recommended)");
210 } else {
211 ();
212 }
213 } keys %$selected;
214 }
215  
216 =item _renamed_unrequested($urpm, $selected, $rejected)
217  
218 Returns the packages obsoleting packages marked "unrequested"
219  
220 =cut
221  
222 #- side-effects: none
223 sub _renamed_unrequested {
224 my ($urpm, $selected, $rejected) = @_;
225
226 my @obsoleted = grep { $rejected->{$_}{obsoleted} } keys %$rejected or return;
227  
228 # we have to read the list to know if the old package was marked "unrequested"
229 my $current = unrequested_list($urpm);
230  
231 my %l;
232 foreach my $fn (@obsoleted) {
233 my ($n) = $fn =~ $fullname2name_re;
234 $current->{$n} or next;
235  
236 my ($new_fn) = keys %{$rejected->{$fn}{closure}};
237 my ($new_n) = $new_fn =~ $fullname2name_re;
238  
239 grep { my $pkg = $urpm->{depslist}[$_]; ($pkg->name eq $new_n) && $pkg->flag_installed && $pkg->flag_upgrade } keys %$selected and next;
240 if ($new_n ne $n) {
241 $l{$new_n} = "(obsoletes $fn)";
242 }
243 }
244 %l;
245 }
246  
247 sub new_unrequested {
248 my ($urpm, $state) = @_;
249 (
250 _selected_unrequested($urpm, $state->{selected}, $state->{rejected}),
251 _renamed_unrequested($urpm, $state->{selected}, $state->{rejected}),
252 );
253 }
254  
255 #- side-effects: <root>/var/lib/rpm/installed-through-deps.list
256 sub add_unrequested {
257 my ($urpm, $state) = @_;
258  
259 my %l = new_unrequested($urpm, $state);
260 append_to_file(unrequested_list__file($urpm), join('', map { "$_\t\t$l{$_}\n" } keys %l));
261 }
262  
263 =item check_unrequested_orphans_after_auto_select($urpm)
264  
265 We don't want to check orphans on every auto-select.
266 We do it only after many packages have been added.
267  
268 Returns whether we should look for orphans depending on a threshold.
269  
270 =cut
271  
272 #- side-effects: none
273 sub check_unrequested_orphans_after_auto_select {
274 my ($urpm) = @_;
275 my $f = unrequested_list__file($urpm);
276 my $nb_added = wc_l($f) - wc_l("$f.old");
277 $nb_added >= $urpm->{options}{'nb-of-new-unrequested-pkgs-between-auto-select-orphans-check'};
278 }
279  
280  
281 =item unrequested_orphans_after_remove($urpm, $toremove)
282  
283 This function computes whether removing $toremove packages will create
284 unrequested orphans.
285  
286 It does not return the new orphans since "whatrecommends" is not
287 available,
288  
289 If it detects there are new orphans, _all_unrequested_orphans() must
290 be used to have the list of the orphans
291  
292 =cut
293  
294 #- side-effects: none
295 sub unrequested_orphans_after_remove {
296 my ($urpm, $toremove) = @_;
297  
298 my $db = urpm::db_open_or_die_($urpm);
299 my %toremove = map { $_ => 1 } @$toremove;
300 _unrequested_orphans_after_remove_once($urpm, $db, unrequested_list($urpm), \%toremove);
301 }
302  
303 #- side-effects: none
304 sub _unrequested_orphans_after_remove_once {
305 my ($urpm, $db, $unrequested, $toremove) = @_;
306  
307 # first we get the list of requires/recommends that may be unneeded after removing $toremove
308 my @requires;
309 foreach my $fn (keys %$toremove) {
310 my ($n) = $fn =~ $fullname2name_re;
311  
312 $db->traverse_tag('name', [ $n ], sub {
313 my ($p) = @_;
314 $p->fullname eq $fn or return;
315 push @requires, $p->requires, $p->recommends_nosense;
316 });
317 }
318  
319 foreach my $req (uniq(@requires)) {
320 $db->traverse_tag_find('whatprovides', URPM::property2name($req), sub {
321 my ($p) = @_;
322 $toremove->{$p->fullname} and return; # already done
323 $unrequested->{$p->name} or return;
324 $p->provides_overlap($req) or return;
325  
326 # cool, $p is "unrequested" and will potentially be newly unneeded
327 if (_will_package_be_unneeded($urpm, $db, $toremove, $p)) {
328 $urpm->{debug}("installed " . $p->fullname . " can now be removed") if $urpm->{debug};
329 return 1;
330 } else {
331 $urpm->{debug}("installed " . $p->fullname . " can not be removed") if $urpm->{debug};
332 }
333 0;
334 }) and return 1;
335 }
336 0;
337 }
338  
339 =item _will_package_be_unneeded($urpm, $db, $toremove, $pkg)
340  
341 Return true if $pkg will no more be required after removing $toremove
342  
343 nb: it may wrongly return false for complex loops,
344 but will never wrongly return true
345  
346 =cut
347  
348 #- side-effects: none
349 sub _will_package_be_unneeded {
350 my ($urpm, $db, $toremove, $pkg) = @_;
351  
352 my $required_maybe_loop;
353  
354 foreach my $prop ($pkg->provides) {
355 _will_prop_still_be_needed($urpm, $db, $toremove,
356 scalar($pkg->fullname), $prop, \$required_maybe_loop)
357 and return;
358 }
359  
360 if ($required_maybe_loop) {
361 my ($fullname, @provides) = @$required_maybe_loop;
362 $urpm->{debug}("checking whether $fullname is a dependency loop") if $urpm->{debug};
363  
364 # doing it locally, since we may fail (and so we must backtrack this change)
365 my %ignore = %$toremove;
366 $ignore{$pkg->fullname} = 1;
367  
368 foreach my $prop (@provides) {
369 #- nb: here we won't loop.
370 _will_prop_still_be_needed($urpm, $db, \%ignore,
371 $fullname, $prop, \$required_maybe_loop)
372 and return;
373 }
374 }
375 1;
376 }
377  
378 =item _will_prop_still_be_needed($urpm, $db, $toremove, $fullname, $prop, $required_maybe_loop)
379  
380 Return true if $prop will still be required after removing $toremove
381  
382 =cut
383  
384 #- side-effects: none
385 sub _will_prop_still_be_needed {
386 my ($urpm, $db, $toremove, $fullname, $prop, $required_maybe_loop) = @_;
387  
388 my ($prov, $range) = URPM::property2name_range($prop) or return;
389
390 $db->traverse_tag_find('whatrequires', $prov, sub {
391 my ($p2) = @_;
392 $toremove->{$p2->fullname} and return 0; # this one is going to be removed, skip it
393  
394 foreach ($p2->requires) {
395 my ($pn, $ps) = URPM::property2name_range($_) or next;
396 if ($pn eq $prov && URPM::ranges_overlap($ps, $range)) {
397 #- we found $p2 which requires $prop
398  
399 if ($$required_maybe_loop) {
400 $urpm->{debug}(" installed " . $p2->fullname . " still requires " . $fullname) if $urpm->{debug};
401 return 1;
402 }
403 $urpm->{debug}(" installed " . $p2->fullname . " may still requires " . $fullname) if $urpm->{debug};
404 $$required_maybe_loop = [ scalar $p2->fullname, $p2->provides ];
405 }
406 }
407 0;
408 });
409 }
410  
411 =item _get_current_kernel_package()
412  
413 Return the current kernel's package so that we can filter out current running
414 kernel:
415  
416 =cut
417  
418 sub _get_current_kernel_package() {
419 my $release = (POSIX::uname())[2];
420 # --qf '%{name}' is used in order to provide the right format:
421 -e "/boot/vmlinuz-$release" && ($release, `rpm -qf --qf '%{name}' /boot/vmlinuz-$release`);
422 }
423  
424 =item _replace_kernel_by_its_provide($urpm, $pkg)
425  
426 Take a dep, replace it by the pkg providing it.
427 Eg:
428 Return the current kernel's package so that we can filter out current running
429 kernel:
430  
431 On mdv & mga[1-8], it's for getting the fullname of the matching pkg.
432 Eg: kernel-desktop-5.15.45-1.mga8 -> kernel-desktop-5.15.45-1.mga8-1-1.x86_64
433  
434 On mga9+:
435 We've "kernel-desktop[== 5.15.45-1]", we want to find pkg providing that, eg the NVRA of the pkg named 'kernel-desktop' whose version matches.
436  
437 =cut
438  
439 sub _replace_kernel_by_its_provide {
440 my ($urpm, $pkg) = @_;
441 my ($req) = grep { /^kernel/ } $pkg->requires;
442 my @a = $urpm->find_candidate_packages($req);
443 $a[0];
444 }
445  
446 =item _kernel_callback ($pkg, $unreq_list)
447  
448 Returns list of kernels
449  
450 _fast_ version w/o looking at all non kernel packages requires on
451 kernels (like "urpmi_find_leaves '^kernel'" would)
452  
453 _all_unrequested_orphans blacklists nearly all kernels b/c of packages
454 like 'ndiswrapper' or 'basesystem' that requires 'kernel' (on mga < 9)
455  
456 rationale: other packages only require 'kernel' or a sub package we
457 do not care about (eg: kernel-devel, kernel-firmware, kernel-latest)
458 so it's useless to look at them
459  
460 =cut
461  
462 # @req_by_latest_kernels tracks kernels needed by kernel*-latest
463 # %requested_kernels tracks which pkgs requires which kernel pkg
464 # %kernels tracks !"*-latest" kernels (to be later filtered)
465 my (@req_by_latest_kernels, %requested_kernels, %kernels);
466 sub _kernel_callback {
467 my ($urpm, $pkg, $unreq_list) = @_;
468 my $shortname = $pkg->name;
469 my $n = $pkg->fullname;
470  
471 # only consider kernels (and not main 'kernel' package):
472 # but perform a pass on their requires for dkms like packages that require a specific kernel:
473 if ($shortname !~ /^kernel-/) {
474 foreach (grep { /^kernel/ } $pkg->requires_nosense) {
475 $requested_kernels{$_}{$shortname} = $pkg;
476 }
477 return;
478 }
479  
480 # only consider real kernels (and not kernel-doc and the like):
481 return if $shortname =~ /-(?:source|doc|headers|firmware(?:|-extra|-nonfree))$/;
482  
483 # ignore requested kernels (aka that are not in /var/lib/rpm/installed-through-deps.list)
484 return if !$unreq_list->{$shortname} && $shortname !~ /latest/;
485  
486 # keep track of packages required by latest kernels in order not to try removing requested kernels:
487 if ($n =~ /latest/) {
488 my $kpkg = _replace_kernel_by_its_provide($urpm, $pkg);
489 push @req_by_latest_kernels, scalar $kpkg->fullname if $kpkg;
490 } else {
491 $kernels{$n} = $pkg;
492 }
493 }
494  
495  
496 =item _get_orphan_kernels()
497  
498 Returns list of orphan kernels
499  
500 =cut
501  
502 sub _get_orphan_kernels() {
503 # keep kernels required by kernel-*-latest:
504 delete $kernels{$_} foreach @req_by_latest_kernels;
505 # return list of unused/orphan kernels:
506 \%kernels;
507 }
508  
509  
510 =item _all_unrequested_orphans($urpm, $req, $unreq)
511  
512 Returns the list of "unrequested" orphans.
513  
514 =cut
515  
516 #- side-effects: none
517 sub _all_unrequested_orphans {
518 my ($urpm, $req, $unreq) = @_;
519  
520 my (%l, %provides);
521 # 1- list explicit provides (not files) from installed packages:
522  
523 my $need_expand = 0;
524 foreach my $pkg (@$unreq) {
525 $l{$pkg->fullname} = $pkg;
526 my $n = $pkg->name;
527 # Instead of hardcoding desktop/linus/server/... flavors, blacklist:
528 $need_expand++ if $n =~ /^kernel-(\w+)$/ && !member($1, qw(doc firmware source));
529 push @{$provides{$_}}, $pkg foreach $pkg->provides_nosense;
530 }
531 my $unreq_list = unrequested_list($urpm);
532  
533 # we need to replace/augment eg "kernel-desktop" by the "kernel-desktop-V-R" for each installed kernel:
534 if ($need_expand) {
535 $kernels{$_->fullname} = $_ foreach grep { /^kernel/ } @$unreq;
536 }
537  
538 my ($current_kernel_version, $current_kernel) = _get_current_kernel_package();
539  
540 # 2- check if "unrequested" packages are still needed:
541 while (my $pkg = shift @$req) {
542 # do not do anything regarding kernels if we failed to detect the running one (ie: chroot)
543 _kernel_callback($urpm, $pkg, $unreq_list) if $current_kernel;
544 foreach my $prop ($pkg->requires, $pkg->recommends_nosense) {
545 my $n = URPM::property2name($prop);
546 foreach my $p (@{$provides{$n} || []}) {
547 # FIXME: hackish in order to fix orphaning kernels with virtualbox installed on mga9+
548 # TODO: check if something else that's not orphaned still provides it instead
549 next if $n eq 'kmod(vboxdrv.ko)';
550 my $pfn = $p->fullname;
551 if ($p != $pkg && $l{$pfn} && $p->provides_overlap($prop)) {
552 delete $l{$pfn};
553 push @$req, $p;
554 }
555 }
556 }
557 }
558  
559 # add orphan kernels to the list:
560 my $a = _get_orphan_kernels();
561 add2hash_(\%l, $a);
562  
563 # add packages that require orphan kernels to the list:
564 foreach (keys %$a) {
565 add2hash_(\%l, $requested_kernels{$_});
566 }
567  
568 # do not offer to remove current kernel or DKMS modules for current kernel:
569 delete $l{$current_kernel};
570 # prevent removing orphan kernels if we failed to detect running kernel version:
571 if ($current_kernel_version) {
572 do { delete $l{$_} } foreach grep { /$current_kernel_version/ } keys %l;
573 }
574  
575 [ values %l ];
576 }
577  
578 =item compute_future_unrequested_orphans($urpm, $state)
579  
580 Compute the list of packages that will be unrequested and
581 could potently be removed.
582  
583 =cut
584  
585 #- side-effects: $state->{orphans_to_remove}
586 #- + those of _installed_and_unrequested_lists (<root>/var/lib/rpm/installed-through-deps.list)
587 sub compute_future_unrequested_orphans {
588 my ($urpm, $state) = @_;
589  
590 $urpm->{log}("computing unrequested orphans");
591  
592 my ($current_pkgs, $unrequested) = _installed_and_unrequested_lists($urpm);
593  
594 put_in_hash($unrequested, { new_unrequested($urpm, $state) });
595  
596 my %toremove = map { $_ => 1 } URPM::removed_or_obsoleted_packages($state);
597 my @pkgs = grep { !$toremove{$_->fullname} } @$current_pkgs;
598 push @pkgs, map { $urpm->{depslist}[$_] } keys %{$state->{selected} || {}};
599  
600 my ($unreq, $req) = partition { $unrequested->{$_->name} } @pkgs;
601  
602 $state->{orphans_to_remove} = _all_unrequested_orphans($urpm, $req, $unreq);
603  
604 # nb: $state->{orphans_to_remove} is used when computing ->selected_size
605 }
606  
607  
608 =item get_orphans($urpm)
609  
610 Returns the list of unrequested packages (aka orphans).
611  
612 It is quite fast. the slow part is the creation of
613 $installed_packages_packed (using installed_packages_packed())
614  
615 Used by C<urpmq --auto_orphans>
616  
617 =cut
618  
619 #
620 #- side-effects:
621 #- + those of _installed_req_and_unreq (<root>/var/lib/rpm/installed-through-deps.list)
622 sub get_orphans {
623 my ($urpm) = @_;
624  
625 $urpm->{log}("computing unrequested orphans");
626  
627 my ($req, $unreq) = _installed_req_and_unreq($urpm);
628 _all_unrequested_orphans($urpm, $req, $unreq);
629 }
630  
631 sub _get_now_orphans_raw_msg {
632 my ($urpm) = @_;
633  
634 my $orphans = get_orphans($urpm);
635 my @orphans = map { scalar $_->fullname } @$orphans or return;
636  
637 (scalar(@orphans), add_leading_spaces(join("\n", sort @orphans)));
638 }
639  
640 =item get_now_orphans_gui_msg($urpm)
641  
642 Like get_now_orphans_msg() but more suited for GUIes, it return
643 message about orphan packages.
644  
645 Used by rpmdrake.
646  
647 =cut
648  
649 sub get_now_orphans_gui_msg {
650 my ($urpm) = @_;
651  
652 my ($count, $list) = _get_now_orphans_raw_msg($urpm) or return;
653 join("\n",
654 P("The following package:\n%s\nis now orphaned.",
655 "The following packages:\n%s\nare now orphaned.", $count, $list),
656 undef,
657 P("You may wish to remove it.",
658 "You may wish to remove them.", $count)
659 );
660 }
661  
662  
663 =item get_now_orphans_msg($urpm)
664  
665 Similar to get_now_orphans_gui_msg() but more suited for CLI, it
666 return message about orphan packages.
667  
668 =cut
669  
670 sub get_now_orphans_msg {
671 my ($urpm) = @_;
672  
673 my ($count, $list) = _get_now_orphans_raw_msg($urpm) or return;
674 P("The following package:\n%s\nis now orphaned, if you wish to remove it, you can use \"urpme --auto-orphans\"",
675 "The following packages:\n%s\nare now orphaned, if you wish to remove them, you can use \"urpme --auto-orphans\"",
676 $count, $list) . "\n";
677 }
678  
679  
680 =item add_leading_spaces($string)
681  
682 Add leading spaces to the string and return it.
683  
684 =cut
685  
686 #- side-effects: none
687 sub add_leading_spaces {
688 my ($s) = @_;
689 $s =~ s/^/ /gm;
690 $s;
691 }
692  
693 #- side-effects: none
694 sub installed_leaves {
695 my ($urpm, $o_discard) = @_;
696  
697 my $packages = installed_packages_packed($urpm);
698  
699 my (%l, %provides);
700 foreach my $pkg (@$packages) {
701 next if $o_discard && $o_discard->($pkg);
702 $l{$pkg->name} = $pkg;
703 push @{$provides{$_}}, $pkg foreach $pkg->provides_nosense;
704 }
705  
706 foreach my $pkg (@$packages) {
707 foreach my $prop ($pkg->requires, $pkg->recommends_nosense) {
708 my $n = URPM::property2name($prop);
709 foreach my $p (@{$provides{$n} || []}) {
710 $p != $pkg && $p->provides_overlap($prop) and
711 delete $l{$p->name};
712 }
713 }
714 }
715  
716 [ values %l ];
717 }
718  
719 1;
720  
721  
722 =back
723  
724 =head1 COPYRIGHT
725  
726  
727 Copyright (C) 2008-2010 Mandriva SA
728  
729 Copyright (C) 2011-2020 Mageia
730  
731 =cut
« urpm/mirrors.pm ↑ Summary urpm/parallel_ka_run.pm »