Summarize package statistics, not jobs

To date, the colcon task model has always had a one-to-one relationship
between packages and jobs, despite separation at the code level. All
jobs are associated with a single package, but it is possible to
associate multiple jobs with a single job.

Likely because of this one-to-one relationship, the job identifier and
package name have often been used interchangeably throughout the colcon
codebase. Because all job identifiers must be unique, we'll need to
break this pattern.

This change re-orients the statistics presented in the `console_summary`
event handler around packages by treating multiple jobs for a single
package as if they were a single job, meaning that a package isn't
finished building until ALL of the jobs finish.

Because all _current_ use cases maintain the one-to-one relationship,
this change should not result in any difference in behavior today.

Author: cottsay

colcon_output/event_handler/summary.py

@@ -71,47 +71,62 @@ def _print_summary(self):
         duration = time.monotonic() - self._start_time
         duration_string = format_duration(duration)
 
-        count, job_type, _ = _msg_arguments(
-            self._ended - self._interrupted - self._failed)
+        blocked_jobs = self._queued - self._ended
+
+        # convert jobs to package names
+        ended = {j.task_context.pkg for j in self._ended}
+        interrupted = {j.task_context.pkg for j in self._interrupted}
+        failed = {j.task_context.pkg for j in self._failed}
+        with_stderr = {j.task_context.pkg for j in self._with_stderr}
+        with_test_failures = {
+            j.task_context.pkg for j in self._with_test_failures}
+        blocked = {j.task_context.pkg for j in blocked_jobs}
+
+        # packages with successful jobs and blocked jobs are "interrupted"
+        interrupted |= ended & blocked - failed
+
+        # truly "blocked" packages have no jobs attempted
+        blocked -= ended
+
+        count, job_type, _ = _msg_arguments(ended - interrupted - failed)
         print('Summary: {count} {job_type} finished '
               '[{duration_string}]'.format_map(locals()))
 
-        if self._failed:
-            count, job_type, names = _msg_arguments(self._failed)
+        if failed:
+            count, job_type, names = _msg_arguments(failed)
             print('  {count} {job_type} failed: {names}'
                   .format_map(locals()))
 
-        if self._interrupted:
-            count, job_type, names = _msg_arguments(self._interrupted)
+        if interrupted:
+            count, job_type, names = _msg_arguments(interrupted)
             print('  {count} {job_type} aborted: {names}'
                   .format_map(locals()))
 
-        if self._with_stderr:
-            count, job_type, names = _msg_arguments(self._with_stderr)
+        if with_stderr:
+            count, job_type, names = _msg_arguments(with_stderr)
             print(
                 '  {count} {job_type} had stderr output: {names}'
                 .format_map(locals()))
 
-        if self._with_test_failures:
-            count, job_type, names = _msg_arguments(
-                self._with_test_failures)
+        if with_test_failures:
+            count, job_type, names = _msg_arguments(with_test_failures)
             print(
                 '  {count} {job_type} had test failures: {names}'
                 .format_map(locals()))
 
-        if len(self._queued) > len(self._ended):
-            count = len(self._queued - self._ended)
+        if blocked:
+            count = len(blocked)
             job_type = get_job_type_word_form(count)
             print(
                 '  {count} {job_type} not processed'
                 .format_map(locals()))
 
 
-def _msg_arguments(jobs):
+def _msg_arguments(packages):
     return (
-        len(jobs),
-        get_job_type_word_form(len(jobs)),
-        ' '.join(sorted(j.task.context.pkg.name for j in jobs)),
+        len(packages),
+        get_job_type_word_form(len(packages)),
+        ' '.join(sorted(p.name for p in packages)),
     )