docs: def continue_abort(self,
                       root_pipeline_key,
                       cursor=None,
                       max_to_notify=_MAX_ABORTS_TO_BEGIN):
      """Sends the abort signal to all children for a root pipeline.
  
      Args:
        root_pipeline_key: db.Key of the root pipeline to abort.
        cursor: The query cursor for enumerating _PipelineRecords when inserting
          tasks to cause child pipelines to terminate.
        max_to_notify: Used for testing.
      """
      if not isinstance(root_pipeline_key, db.Key):
        root_pipeline_key = db.Key(root_pipeline_key)
      # NOTE: The results of this query may include _PipelineRecord instances
      # that are not actually "reachable", meaning you cannot get to them by
      # starting at the root pipeline and following "fanned_out" onward. This
      # is acceptable because even these defunct _PipelineRecords will properly
      # set their status to ABORTED when the signal comes, regardless of any
      # other status they may have had.
      #
      # The only gotcha here is if a Pipeline's finalize method somehow modifies
      # its inputs (like deleting an input file). In the case there are
      # unreachable child pipelines, it will appear as if two finalize methods
      # have been called instead of just one. The saving grace here is that
      # finalize must be idempotent, so this *should* be harmless.
      query = (
          _PipelineRecord.all(cursor=cursor)
          .filter('root_pipeline =', root_pipeline_key))
      results = query.fetch(max_to_notify)
  
      task_list = []
      for pipeline_record in results:
        if pipeline_record.status not in (
            _PipelineRecord.RUN, _PipelineRecord.WAITING):
          continue
  
        pipeline_key = pipeline_record.key()
        task_list.append(taskqueue.Task(
            name='%s-%s-abort' % (self.task_name, pipeline_key.name()),
            url=self.abort_handler_path,
            params=dict(pipeline_key=pipeline_key, purpose=_BarrierRecord.ABORT),
            headers={'X-Ae-Pipeline-Key': pipeline_key}))
  
      # Task continuation with sequence number to prevent fork-bombs.
      if len(results) == max_to_notify:
        the_match = re.match('(.*)-([0-9]+)', self.task_name)
        if the_match:
          prefix = the_match.group(1)
          end = int(the_match.group(2)) + 1
        else:
          prefix = self.task_name
          end = 0
        task_list.append(taskqueue.Task(
            name='%s-%d' % (prefix, end),
            url=self.fanout_abort_handler_path,
            params=dict(root_pipeline_key=root_pipeline_key,
                        cursor=query.cursor())))
  
      if task_list:
        try:
          taskqueue.Queue(self.queue_name).add(task_list)
        except (taskqueue.TombstonedTaskError, taskqueue.TaskAlreadyExistsError):
          pass