Method _handle_group_chord_error

celery/backends/base.py:337–403

Handle chord errors when the callback is a group. When a chord header fails and the body is a group, we need to: 1. Revoke all pending tasks in the group body 2. Mark them as failed with the chord error 3. Call error callbacks for each task This prevents the

(self, group_callback, backend, exc=None)

            return backend.fail_from_current_stack(callback.id, exc=exc)

    def _handle_group_chord_error(self, group_callback, backend, exc=None):
        """Handle chord errors when the callback is a group.

        When a chord header fails and the body is a group, we need to:
        1. Revoke all pending tasks in the group body
        2. Mark them as failed with the chord error
        3. Call error callbacks for each task

        This prevents the group body tasks from hanging indefinitely (#8786)
        """

        # Extract original exception from ChordError if available
        if isinstance(exc, ChordError) and hasattr(exc, '__cause__') and exc.__cause__:
            original_exc = exc.__cause__
        else:
            original_exc = exc

        try:
            # Freeze the group to get the actual GroupResult with task IDs
            frozen_group = group_callback.freeze()

            if isinstance(frozen_group, GroupResult):
                # revoke all tasks in the group to prevent execution
                frozen_group.revoke()

                # Handle each task in the group individually
                for result in frozen_group.results:
                    try:
                        # Create fake request for error callbacks
                        fake_request = _create_fake_task_request(
                            task_id=result.id,
                            errbacks=group_callback.options.get("link_error", []),
                            task_name=getattr(result, 'task', 'unknown')
                        )

                        # Call error callbacks for this task with original exception
                        try:
                            backend._call_task_errbacks(fake_request, original_exc, None)
                        except Exception:  # pylint: disable=broad-except
                            # continue on exception to be sure to iter to all the group tasks
                            pass

                        # Mark the individual task as failed with original exception
                        backend.fail_from_current_stack(result.id, exc=original_exc)

                    except Exception as task_exc:  # pylint: disable=broad-except
                        # Log error but continue with other tasks
                        logger.exception(
                            'Failed to handle chord error for task %s: %r',
                            getattr(result, 'id', 'unknown'), task_exc
                        )

                # Also mark the group itself as failed if it has an ID
                frozen_group_id = getattr(frozen_group, 'id', None)
                if frozen_group_id:
                    backend.mark_as_failure(frozen_group_id, original_exc)

            return None