cpm/Master.pm untested

filter: Statementstmt 0.0% 0 / 505 Branchbran 0.0% 0 / 216 Conditioncond 0.0% 0 / 158 MC/DCmcdc 0.0% 0 / 97 Subroutinesub 0.0% 0 / 55 Podpod 0.0% 0 / 41 totaltotal 0.0% 0 / 1072 CC 109 SCAR 37.6
CC
109
Cov
0%
info
132.0
is_satisfied
90.0
_final_install_distributions
72.0
CRAP 43.1
1 package App::cpm::Master;
2 use v5.24;
3 use warnings;
4 use experimental qw(lexical_subs signatures);
5  
6 use App::cpm::CircularDependency;
7 use App::cpm::Distribution;
8 use App::cpm::Logger;
9 use App::cpm::Logger::Terminal;
10 use App::cpm::Task;
11 use App::cpm::version;
12 use CPAN::DistnameInfo;
13 use Module::Metadata;
14 use File::pushd 'pushd';
15  
16 sub new ($class, %argv) {
17 my $self = bless {
18 %argv,
19 installed_distributions => 0,
20 tasks => +{},
21 distributions => +{},
22 dependency_ready => +{},
23 _fail_resolve => +{},
24 _fail_install => +{},
25 _is_installed => +{},
26 }, $class;
27 if ($self->{target_perl}) {
28 require Module::CoreList;
29 if (!exists $Module::CoreList::version{$self->{target_perl}}) {
30 die "Module::CoreList does not have target perl $self->{target_perl} entry, abort.\n";
31 }
32 if (!exists $Module::CoreList::version{$]}) {
33 die "Module::CoreList does not have our perl $] entry, abort.\n";
34 }
35 }
36 if (!$self->{global}) {
37 if (eval { require Module::CoreList }) {
38 if (!exists $Module::CoreList::version{$]}) {
39 die "Module::CoreList does not have our perl $] entry, abort.\n";
40 }
41 $self->{_has_corelist} = 1;
42 } else {
43 my $msg = "You don't have Module::CoreList. "
44 . "The local-lib may result in incomplete self-contained directory.";
45 App::cpm::Logger->log(result => "WARN", message => $msg);
46 }
47 }
48 $self;
49 }
50  
51 sub fail ($self, $ctx) {
52 my @fail_resolve = sort keys $self->{_fail_resolve}->%*;
53 my @fail_install = sort keys $self->{_fail_install}->%*;
54 my @not_installed = grep { !$self->{_fail_install}{$_->distfile} && !$_->installed } $self->_final_install_distributions(1);
55 return if !@fail_resolve && !@fail_install && !@not_installed;
56  
57 my $detector = App::cpm::CircularDependency->new;
58 for my $dist (@not_installed) {
59 my $req = $dist->requirements([qw(configure build test runtime)])->as_array;
60 $detector->add($dist->distfile, $dist->provides, $req);
61 }
62 $detector->finalize;
63  
64 my $detected = $detector->detect;
65 for my $distfile (sort keys $detected->%*) {
66 my $distvname = $self->distribution($distfile)->distvname;
67 my @circular = $detected->{$distfile}->@*;
68 my $msg = join " -> ", map { $self->distribution($_)->distvname } @circular;
69 local $ctx->{logger}{context} = $distvname;
70 $ctx->log("Detected circular dependencies $msg");
71 $ctx->log("Failed to install distribution");
72 }
73 for my $dist (sort { $a->distvname cmp $b->distvname } grep { !$detected->{$_->distfile} } @not_installed) {
74 local $ctx->{logger}{context} = $dist->distvname;
75 $ctx->log("Failed to install distribution, "
76 ."because of installing some dependencies failed");
77 }
78  
79 my @fail_install_name = map { CPAN::DistnameInfo->new($_)->distvname || $_ } @fail_install;
80 my @not_installed_name = map { $_->distvname } @not_installed;
81 if (@fail_resolve || @fail_install_name) {
82 $ctx->log("--");
83 $ctx->log(
84 "Installation failed. "
85 . "The direct cause of the failure comes from the following packages/distributions; "
86 . "you may want to grep this log file by them:"
87 );
88 $ctx->log(" * $_") for @fail_resolve, sort @fail_install_name;
89 }
90 { resolve => \@fail_resolve, install => [sort @fail_install_name, @not_installed_name] };
91 }
92  
93 sub tasks ($self) { values $self->{tasks}->%* }
94  
95 sub add_task ($self, $ctx, %task) {
96 my $new = App::cpm::Task->new(%task);
97 if (my ($existing) = grep { $_->equals($new) } $self->tasks) {
98 $existing->{final_target} ||= $new->{final_target};
99 return 0;
100 } else {
101 $self->{tasks}{$new->uid} = $new;
102 return 1;
103 }
104 }
105  
106 sub get_task ($self, $ctx) {
107 if (my @task = grep { !$_->in_charge } $self->tasks) {
108 return @task;
109 }
110 $self->_add_tasks($ctx);
111 return if !$self->tasks;
112 if (my @task = grep { !$_->in_charge } $self->tasks) {
113 return @task;
114 }
115 return;
116 }
117  
118 sub register_result ($self, $ctx, $result) {
119 my ($task) = grep { $_->uid eq $result->{uid} } $self->tasks;
120 die "Missing task that has uid=$result->{uid}" if !$task;
121  
122 $task->%* = $result->%*; # XXX
123  
124 my $logged = $self->info($task);
125 my $method = "_register_@{[$task->{type}]}_result";
126 $self->$method($ctx, $task);
127 $self->remove_task($ctx, $task);
128  
129 return 1;
130 }
131  
132 sub info ($self, $task) {
133 my $type = $task->type;
134 if (!$App::cpm::Logger::VERBOSE && $task->{ok}) {
135 return if !($self->{notest} && $type eq "fetch" && $task->{prebuilt})
136 && !($self->{notest} && $type eq "build" && !$task->{prebuilt})
137 && !(!$self->{notest} && $type eq "test");
138 }
139 my $name = $task->distvname;
140 my ($message, $optional);
141 if ($type eq "resolve") {
142 $message = $task->{package};
143 $message .= " -> $name" . ($task->{ref} ? "\@$task->{ref}" : "") if $task->{ok};
144 $optional = "from $task->{from}" if $task->{ok} and $task->{from};
145 } else {
146 $message = $name;
147 $optional = "using cache" if $type eq "fetch" and $task->{using_cache};
148 $optional = "using prebuilt" if $task->{prebuilt};
149 }
150 my $elapsed = defined $task->{elapsed} ? sprintf "(%.3fsec) ", $task->{elapsed} : "";
151  
152 App::cpm::Logger->log(
153 pid => $task->{pid},
154 type => $type,
155 result => $task->{ok} ? "DONE" : "FAIL",
156 message => "$elapsed$message",
157 optional => $optional,
158 );
159 return 1;
160 }
161  
162 sub enable_terminal_logger ($self, %argv) {
163 $self->{terminal_logger} = App::cpm::Logger::Terminal->new(%argv);
164 }
165  
166 sub _terminal_summary_count ($self) {
167 my $state = $self->{notest} ? "built" : "tested";
168 scalar grep { $_->$state || $_->installed } $self->distributions;
169 }
170  
171 sub _terminal_summary_total ($self) {
172 my $distributions = scalar keys $self->{distributions}->%*;
173 my $tasks = scalar keys $self->{tasks}->%*;
174 $distributions > $tasks ? $distributions : $tasks;
175 }
176  
177 sub log_task ($self) {
178 my $terminal = $self->{terminal_logger};
179 my $lines = $terminal->new_lines;
180  
181 for my $pid (sort { $a <=> $b } keys $terminal->{pids}->%*) {
182 my ($task) = grep { ($_->in_charge || 0) == $pid } $self->tasks;
183 $lines->set_worker($pid, $task);
184 }
185  
186 $lines->set_summary($self->_terminal_summary_count, $self->_terminal_summary_total);
187 $terminal->write($lines);
188 }
189  
190 sub finalize_terminal_logger ($self) {
191 my $terminal = delete $self->{terminal_logger};
192 $terminal->finalize;
193 }
194  
195 sub remove_task ($self, $ctx, $task) {
196 delete $self->{tasks}{$task->uid};
197 }
198  
199 sub distributions ($self) { values $self->{distributions}->%* }
200  
201 sub distribution ($self, $distfile) {
202 $self->{distributions}{$distfile};
203 }
204  
205 sub install_phase_state ($self, $dist) {
206 return "built" if $dist->prebuilt;
207 return $self->{notest} ? "built" : "tested";
208 }
209  
210 sub dependency_ready ($self, $dist, @argv) {
211 my $distfile = $dist->distfile;
212 $self->{dependency_ready}{$distfile} = $argv[0] ? 1 : 0 if @argv;
213 $self->{dependency_ready}{$distfile};
214 }
215  
216 sub _resolved_distribution ($self, $package, $version_range = undef) {
217 my $key = join "\0", $package, $version_range // "";
218 return $self->{_resolved_distribution}{$key} if exists $self->{_resolved_distribution}{$key};
219  
220 my ($resolved) = grep { $_->providing($package, $version_range) } $self->distributions;
221 $self->{_resolved_distribution}{$key} = $resolved;
222 $resolved;
223 }
224  
225 sub dependency_env_for ($self, $dist, $phases, $seen = undef, $found = undef) {
226 $seen ||= {};
227 $found ||= {};
228  
229 for my $req ($dist->requirements($phases)->as_array->@*) {
230 my ($package, $version_range) = $req->@{qw(package version_range)};
231 next if $package eq "perl";
232 next if $self->{target_perl} and $self->is_core($package, $version_range);
233  
234 my $resolved = $self->_resolved_distribution($package, $version_range);
235 if (!$resolved) {
236 next if $self->is_installed($package, $version_range);
237 next;
238 }
239 next if !$self->dependency_ready($resolved);
240 next if $seen->{$resolved->distfile}++;
241  
242 $found->{$resolved->distfile} = $resolved;
243 $self->dependency_env_for($resolved, 'runtime', $seen, $found);
244 }
245  
246 my (@libs, @paths);
247 for my $resolved (values $found->%*) {
248 push @libs, $resolved->builder->libs->@*;
249 push @paths, $resolved->builder->paths->@*;
250 }
251  
252 return {
253 dependency_libs => \@libs,
254 dependency_paths => \@paths,
255 };
256 }
257  
258 sub _final_install_distributions ($self, $include_unready = 0) {
259 return grep { $include_unready || $self->dependency_ready($_) } $self->distributions
260 if $self->{final_install} eq "all";
261  
262 my %seen;
263 my @todo = grep { $_->final_target } $self->distributions;
264 my @install;
265 while (my $dist = shift @todo) {
266 next if $seen{$dist->distfile}++;
267 push @install, $dist if $include_unready || $self->dependency_ready($dist);
268  
269 for my $req ($dist->requirements('runtime')->as_array->@*) {
270 my ($package, $version_range) = $req->@{qw(package version_range)};
271 next if $package eq "perl";
272 next if $self->{target_perl} and $self->is_core($package, $version_range);
273  
274 my $resolved = $self->_resolved_distribution($package, $version_range);
275 next if !$resolved;
276 next if $self->is_installed($package, $version_range);
277 push @todo, $resolved;
278 }
279 }
280 return @install;
281 }
282  
283 sub install_distributions ($self, $ctx) {
284 my @dist = $self->_final_install_distributions;
285 return if !@dist;
286  
287 warn "Installing distributions...\n" if $self->{progress} eq "plain" && !$App::cpm::Logger::VERBOSE;
288 $ctx->log("Installing distributions");
289  
290 for my $dist (sort { $a->distvname cmp $b->distvname } @dist) {
291 my $guard = pushd $dist->directory;
292  
293 local $ctx->{logger}{context} = $dist->distvname;
294 $ctx->log("Installing distribution");
295 my $env = $dist->builder->needs_install_env
296 ? $self->dependency_env_for($dist, [qw(configure build runtime)])
297 : { dependency_libs => [], dependency_paths => [] };
298 my $ok = $dist->builder->install($ctx, $env->{dependency_libs}, $env->{dependency_paths});
299 if ($ok) {
300 $dist->installed(1);
301 $self->{installed_distributions}++;
302 $ctx->log("Successfully installed distribution");
303 if ($App::cpm::Logger::VERBOSE || $self->{progress} eq "tty") {
304 App::cpm::Logger->log(
305 type => "install",
306 result => "DONE",
307 message => $dist->distvname,
308 ($dist->prebuilt ? (optional => "using prebuilt") : ()),
309 );
310 }
311 } else {
312 $self->{_fail_install}{$dist->distfile}++;
313 $ctx->log("Failed to install distribution");
314 App::cpm::Logger->log(
315 type => "install",
316 result => "FAIL",
317 message => $dist->distvname,
318 ($dist->prebuilt ? (optional => "using prebuilt") : ()),
319 );
320 }
321 }
322 return 1;
323 }
324  
325 sub _add_tasks ($self, $ctx) {
326 while (1) {
327 my $changed = 0;
328  
329 if ($self->{notest}) {
330 $changed += $self->_mark_built_dependency_ready($ctx);
331 } else {
332 $changed += $self->_mark_tested_dependency_ready($ctx);
333 }
334  
335 $changed += $self->_add_fetch_tasks($ctx);
336 $changed += $self->_add_configure_tasks($ctx);
337 $changed += $self->_add_build_tasks($ctx);
338  
339 if (!$self->{notest}) {
340 $changed += $self->_add_test_tasks($ctx);
341 }
342  
343 last if !$changed;
344 }
345 }
346  
347 sub _mark_built_dependency_ready ($self, $ctx) {
348 my $changed = 0;
349 my @distributions = grep { !$self->{_fail_install}{$_->distfile} } $self->distributions;
350 if (my @dists = grep { $_->built && !$self->dependency_ready($_) } @distributions) {
351 for my $dist (@dists) {
352 my $dist_requirements = $dist->requirements('runtime')->as_array;
353 my ($is_satisfied, @need_resolve) = $self->is_satisfied($dist_requirements);
354 if ($is_satisfied) {
355 $self->dependency_ready($dist, 1);
356 $changed++;
357 } elsif (!defined $is_satisfied) {
358 local $ctx->{logger}{context} = $dist->distvname;
359 my ($req) = grep { $_->{package} eq "perl" } $dist_requirements->@*;
360 my $msg = sprintf "%s requires perl %s, but you have only %s",
361 $dist->distvname, $req->{version_range}, $self->{target_perl} || $];
362 $ctx->log($msg);
363 App::cpm::Logger->log(result => "FAIL", message => $msg);
364 $self->{_fail_install}{$dist->distfile}++;
365 $changed++;
366 } elsif (@need_resolve and !$dist->deps_registered) {
367 local $ctx->{logger}{context} = $dist->distvname;
368 $dist->deps_registered(1);
369 my $msg = sprintf "Found runtime prerequisites: %s",
370 join(", ", map { sprintf "%s (%s)", $_->{package}, $_->{version_range} || 0 } @need_resolve);
371 $ctx->log($msg);
372 my $ok = $self->_register_resolve_task($ctx, @need_resolve);
373 $self->{_fail_install}{$dist->distfile}++ if !$ok;
374 $changed++;
375 }
376 }
377 }
378 return $changed;
379 }
380  
381 sub _mark_tested_dependency_ready ($self, $ctx) {
382 my @distributions = grep { !$self->{_fail_install}{$_->distfile} } $self->distributions;
383 my @dists = grep { $_->tested && !$self->dependency_ready($_) } @distributions;
384 $self->dependency_ready($_, 1) for @dists;
385 return scalar @dists;
386 }
387  
388 sub _add_fetch_tasks ($self, $ctx) {
389 my $changed = 0;
390 my @distributions = grep { !$self->{_fail_install}{$_->distfile} } $self->distributions;
391 if (my @dists = grep { $_->resolved && !$_->registered } @distributions) {
392 for my $dist (@dists) {
393 $dist->registered(1);
394 $self->add_task(
395 $ctx,
396 type => "fetch",
397 distfile => $dist->{distfile},
398 source => $dist->source,
399 uri => $dist->uri,
400 ref => $dist->ref,
401 );
402 $changed++;
403 }
404 }
405 return $changed;
406 }
407  
408 sub _add_configure_tasks ($self, $ctx) {
409 my $changed = 0;
410 my @distributions = grep { !$self->{_fail_install}{$_->distfile} } $self->distributions;
411 if (my @dists = grep { $_->fetched && !$_->registered } @distributions) {
412 my @phase = qw(configure);
413 for my $dist (@dists) {
414 local $ctx->{logger}{context} = $dist->distvname;
415 my $dist_requirements = $dist->requirements(\@phase)->as_array;
416 my ($is_satisfied, @need_resolve) = $self->is_satisfied($dist_requirements);
417 if ($is_satisfied) {
418 $dist->registered(1);
419 my $env = $self->dependency_env_for($dist, \@phase);
420 $self->add_task(
421 $ctx,
422 type => "configure",
423 meta => $dist->meta,
424 directory => $dist->directory,
425 distfile => $dist->{distfile},
426 provides => $dist->provides,
427 source => $dist->source,
428 uri => $dist->uri,
429 distvname => $dist->distvname,
430 $env->%*,
431 );
432 $changed++;
433 } elsif (!defined $is_satisfied) {
434 my ($req) = grep { $_->{package} eq "perl" } $dist_requirements->@*;
435 my $msg = sprintf "%s requires perl %s, but you have only %s",
436 $dist->distvname, $req->{version_range}, $self->{target_perl} || $];
437 $ctx->log($msg);
438 App::cpm::Logger->log(result => "FAIL", message => $msg);
439 $self->{_fail_install}{$dist->distfile}++;
440 $changed++;
441 } elsif (@need_resolve and !$dist->deps_registered) {
442 $dist->deps_registered(1);
443 my $msg = sprintf "Found configure dependencies: %s",
444 join(", ", map { sprintf "%s (%s)", $_->{package}, $_->{version_range} || 0 } @need_resolve);
445 $ctx->log($msg);
446 my $ok = $self->_register_resolve_task($ctx, @need_resolve);
447 $self->{_fail_install}{$dist->distfile}++ if !$ok;
448 $changed++;
449 }
450 }
451 }
452 return $changed;
453 }
454  
455 sub _add_build_tasks ($self, $ctx) {
456 my $changed = 0;
457 my @distributions = grep { !$self->{_fail_install}{$_->distfile} } $self->distributions;
458 if (my @dists = grep { $_->configured && !$_->registered } @distributions) {
459 my @phase = qw(configure runtime build);
460 for my $dist (@dists) {
461 local $ctx->{logger}{context} = $dist->distvname;
462 my $dist_requirements = $dist->requirements(\@phase)->as_array;
463 my ($is_satisfied, @need_resolve) = $self->is_satisfied($dist_requirements);
464 if ($is_satisfied) {
465 $dist->registered(1);
466 my $env = $self->dependency_env_for($dist, \@phase);
467 $self->add_task(
468 $ctx,
469 type => "build",
470 meta => $dist->meta,
471 directory => $dist->directory,
472 distfile => $dist->{distfile},
473 uri => $dist->uri,
474 builder => $dist->builder,
475 provides => $dist->provides,
476 $env->%*,
477 );
478 $changed++;
479 } elsif (!defined $is_satisfied) {
480 my ($req) = grep { $_->{package} eq "perl" } $dist_requirements->@*;
481 my $msg = sprintf "%s requires perl %s, but you have only %s",
482 $dist->distvname, $req->{version_range}, $self->{target_perl} || $];
483 $ctx->log($msg);
484 App::cpm::Logger->log(result => "FAIL", message => $msg);
485 $self->{_fail_install}{$dist->distfile}++;
486 $changed++;
487 } elsif (@need_resolve and !$dist->deps_registered) {
488 $dist->deps_registered(1);
489 my $msg = sprintf "Found build prerequisites: %s",
490 join(", ", map { sprintf "%s (%s)", $_->{package}, $_->{version_range} || 0 } @need_resolve);
491 $ctx->log($msg);
492 my $ok = $self->_register_resolve_task($ctx, @need_resolve);
493 $self->{_fail_install}{$dist->distfile}++ if !$ok;
494 $changed++;
495 }
496 }
497 }
498 return $changed;
499 }
500  
501 sub _add_test_tasks ($self, $ctx) {
502 my $changed = 0;
503 my @distributions = grep { !$self->{_fail_install}{$_->distfile} } $self->distributions;
504 if (my @dists = grep { $_->built && !$_->registered } @distributions) {
505 for my $dist (@dists) {
506 local $ctx->{logger}{context} = $dist->distvname;
507 my @phase = qw(configure build runtime test);
508 my $dist_requirements = $dist->requirements(\@phase)->as_array;
509 my ($is_satisfied, @need_resolve) = $self->is_satisfied($dist_requirements);
510 if ($is_satisfied) {
511 $dist->registered(1);
512 my $env = $self->dependency_env_for($dist, \@phase);
513 $self->add_task(
514 $ctx,
515 type => "test",
516 meta => $dist->meta,
517 directory => $dist->directory,
518 distfile => $dist->{distfile},
519 uri => $dist->uri,
520 builder => $dist->builder,
521 provides => $dist->provides,
522 $env->%*,
523 );
524 $changed++;
525 } elsif (!defined $is_satisfied) {
526 my ($req) = grep { $_->{package} eq "perl" } $dist_requirements->@*;
527 my $msg = sprintf "%s requires perl %s, but you have only %s",
528 $dist->distvname, $req->{version_range}, $self->{target_perl} || $];
529 $ctx->log($msg);
530 App::cpm::Logger->log(result => "FAIL", message => $msg);
531 $self->{_fail_install}{$dist->distfile}++;
532 $changed++;
533 } elsif (@need_resolve and !$dist->deps_registered) {
534 $dist->deps_registered(1);
535 my $msg = sprintf "Found test prerequisites: %s",
536 join(", ", map { sprintf "%s (%s)", $_->{package}, $_->{version_range} || 0 } @need_resolve);
537 $ctx->log($msg);
538 my $ok = $self->_register_resolve_task($ctx, @need_resolve);
539 $self->{_fail_install}{$dist->distfile}++ if !$ok;
540 $changed++;
541 }
542 }
543 }
544 return $changed;
545 }
546  
547 sub _register_resolve_task ($self, $ctx, @package) {
548 my $ok = 1;
549 for my $package (@package) {
550 if ($self->{_fail_resolve}{$package->{package}}
551 || $self->{_fail_install}{$package->{package}}
552 ) {
553 $ok = 0;
554 next;
555 }
556  
557 $self->add_task(
558 $ctx,
559 type => "resolve",
560 package => $package->{package},
561 version_range => $package->{version_range},
562 );
563 }
564 return $ok;
565 }
566  
567 sub is_satisfied_perl_version ($self, $version_range) {
568 App::cpm::version->parse($self->{target_perl} || $])->satisfy($version_range);
569 }
570  
571 sub is_installed ($self, $package, $version_range) {
572 my $wantarray = wantarray;
573 if (exists $self->{_is_installed}{$package}) {
574 if ($self->{_is_installed}{$package}->satisfy($version_range)) {
575 return $wantarray ? (1, $self->{_is_installed}{$package}) : 1;
576 }
577 }
578 my $info = Module::Metadata->new_from_module($package, inc => $self->{search_inc});
579 return if !$info;
580  
581 if (!$self->{global} and $self->{_has_corelist} and $self->_in_core_inc($info->filename)) {
582 # https://github.com/miyagawa/cpanminus/blob/7b574ede70cebce3709743ec1727f90d745e8580/Menlo-Legacy/lib/Menlo/CLI/Compat.pm#L1783-L1786
583 # if found package in core inc,
584 # but it does not list in CoreList,
585 # we should treat it as not being installed
586 return if !exists $Module::CoreList::version{$]}{$info->name};
587 }
588 my $current_version = $self->{_is_installed}{$package}
589 = App::cpm::version->parse($info->version);
590 my $ok = $current_version->satisfy($version_range);
591 $wantarray ? ($ok, $current_version) : $ok;
592 }
593  
594 sub _in_core_inc ($self, $file) {
595 !!grep { $file =~ /^\Q$_/ } $self->{core_inc}->@*;
596 }
597  
598 sub is_core ($self, $package, $version_range) {
599 my $target_perl = $self->{target_perl};
600 if (exists $Module::CoreList::version{$target_perl}{$package}) {
601 if (!exists $Module::CoreList::version{$]}{$package}) {
602 if (!$self->{_removed_core}{$package}++) {
603 my $t = App::cpm::version->parse($target_perl)->normal;
604 my $v = App::cpm::version->parse($])->normal;
605 App::cpm::Logger->log(
606 result => "WARN",
607 message => "$package used to be core in $t, but not in $v, so will be installed",
608 );
609 }
610 return;
611 }
612 return 1 if !$version_range;
613 my $core_version = $Module::CoreList::version{$target_perl}{$package};
614 return App::cpm::version->parse($core_version)->satisfy($version_range);
615 }
616 return;
617 }
618  
619 # 0: not satisfied, need wait for satisfying requirements
620 # 1: satisfied
621 # undef: not satisfied because of perl version
622 sub is_satisfied ($self, $requirements) {
623 my $is_satisfied = 1;
624 my @need_resolve;
625 my @distributions = $self->distributions;
626 for my $req ($requirements->@*) {
627 my ($package, $version_range) = $req->@{qw(package version_range)};
628 if ($package eq "perl") {
629 $is_satisfied = undef if !$self->is_satisfied_perl_version($version_range);
630 next;
631 }
632 next if $self->{target_perl} and $self->is_core($package, $version_range);
633 my $resolved = $self->_resolved_distribution($package, $version_range);
634 if ($resolved) {
635 next if $self->dependency_ready($resolved);
636 }
637 next if $self->is_installed($package, $version_range);
638  
639 $is_satisfied = 0 if defined $is_satisfied;
640 if (!$resolved) {
641 push @need_resolve, $req;
642 }
643 }
644 return ($is_satisfied, @need_resolve);
645 }
646  
647 sub add_distribution ($self, $distribution) {
648 my $distfile = $distribution->distfile;
649 if (my $already = $self->{distributions}{$distfile}) {
650 if ($already->resolved) {
651 $already->overwrite_provide($_) for $distribution->provides->@*;
652 delete $self->{_resolved_distribution};
653 }
654 return 0;
655 } else {
656 $self->{distributions}{$distfile} = $distribution;
657 delete $self->{_resolved_distribution};
658 return 1;
659 }
660 }
661  
662 sub _register_resolve_result ($self, $ctx, $task) {
663 if (!$task->is_success) {
664 $self->{_fail_resolve}{$task->{package}}++;
665 return;
666 }
667  
668 local $ctx->{logger}{context} = $task->{package};
669 if ($task->{distfile} and $task->{distfile} =~ m{/perl-5[^/]+$}) {
670 my $message = "$task->{package} is a core module.";
671 $ctx->log($message);
672 App::cpm::Logger->log(
673 result => "DONE",
674 type => "install",
675 message => $message,
676 );
677 return;
678 }
679  
680 if (!$task->{reinstall}) {
681 my $want = $task->{version_range} || $task->{version};
682 my ($ok, $local) = $self->is_installed($task->{package}, $want);
683 if ($ok) {
684 my $message = $task->{package} . (
685 App::cpm::version->parse($task->{version}) != $local
686 ? ", you already have $local"
687 : " is up to date. ($local)"
688 );
689 $ctx->log($message);
690 App::cpm::Logger->log(
691 result => "DONE",
692 type => "install",
693 message => $message,
694 );
695 return;
696 }
697 }
698  
699 my $provides = $task->{provides};
700 if (!$provides or $provides->@* == 0) {
701 my $version = App::cpm::version->parse($task->{version}) || 0;
702 $provides = [{package => $task->{package}, version => $version}];
703 }
704 my $distribution = App::cpm::Distribution->new(
705 source => $task->{source},
706 uri => $task->{uri},
707 provides => $provides,
708 distfile => $task->{distfile},
709 ref => $task->{ref},
710 final_target => $task->{final_target},
711 );
712 if (!$self->add_distribution($distribution) && $task->{final_target}) {
713 $self->distribution($distribution->distfile)->final_target(1);
714 }
715 }
716  
717 sub _register_fetch_result ($self, $ctx, $task) {
718 if (!$task->is_success) {
719 $self->{_fail_install}{$task->distfile}++;
720 return;
721 }
722 my $distribution = $self->distribution($task->distfile);
723 $distribution->directory($task->{directory});
724 $distribution->meta($task->{meta});
725 $distribution->provides($task->{provides});
726  
727 if ($task->{prebuilt}) {
728 $distribution->built(1);
729 $distribution->requirements($_ => $task->{requirements}{$_}) for keys $task->{requirements}->%*;
730 $distribution->builder($task->{builder});
731 $distribution->prebuilt(1);
732 } else {
733 $distribution->fetched(1);
734 $distribution->requirements($_ => $task->{requirements}{$_}) for keys $task->{requirements}->%*;
735 }
736 local $ctx->{logger}{context} = $distribution->distvname;
737 my $msg = join ", ", map { sprintf "%s (%s)", $_->{package}, $_->{version} || 0 } $distribution->provides->@*;
738 $ctx->log("Distribution provides: $msg");
739 return 1;
740 }
741  
742 sub _register_configure_result ($self, $ctx, $task) {
743 if (!$task->is_success) {
744 $self->{_fail_install}{$task->distfile}++;
745 return;
746 }
747 my $distribution = $self->distribution($task->distfile);
748 $distribution->configured(1);
749 $distribution->requirements($_ => $task->{requirements}{$_}) for keys $task->{requirements}->%*;
750 $distribution->builder($task->{builder});
751 return 1;
752 }
753  
754 sub _register_build_result ($self, $ctx, $task) {
755 if (!$task->is_success) {
756 $self->{_fail_install}{$task->distfile}++;
757 return;
758 }
759 my $distribution = $self->distribution($task->distfile);
760 $distribution->built(1);
761 $distribution->builder($task->{builder});
762 return 1;
763 }
764  
765 sub _register_test_result ($self, $ctx, $task) {
766 if (!$task->is_success) {
767 $self->{_fail_install}{$task->distfile}++;
768 return;
769 }
770 my $distribution = $self->distribution($task->distfile);
771 $distribution->tested(1);
772 return 1;
773 }
774  
775 sub installed_distributions ($self) { $self->{installed_distributions} }
776  
777 1;