Method run

salt/cli/batch.py:142–348

Execute the batch run. Generator. For each minion return, yields ``({minion_id: ret_data}, retcode)`` (or the raw event envelope when ``raw=True``). Minion returns carrying ``failed: True`` (and ``failhard`` halt events) are recorded internally but not

(self)

                )

    def run(self):
        """
        Execute the batch run.

        Generator.  For each minion return, yields
        ``({minion_id: ret_data}, retcode)`` (or the raw event envelope
        when ``raw=True``).  Minion returns carrying ``failed: True``
        (and ``failhard`` halt events) are recorded internally but not
        yielded, preserving the pre-Phase-2 yield shape.
        """
        self.minions, self.ping_gen, self.down_minions = self.gather_minions()

        if not self.minions:
            return

        batch_jid = salt.utils.jid.gen_jid(self.opts)
        state = salt.utils.batch_state.create_batch_state(
            self.opts, self.minions, batch_jid, driver="cli"
        )

        # The sync CLI driver does not write under the master's
        # ``cachedir`` itself.  ``cachedir`` is owned by the master
        # daemon's user (typically ``salt``); the CLI is normally
        # invoked as ``root``, so any direct write would pre-create
        # the JID directory with the wrong ownership and trip a
        # ``PermissionError`` in ``local_cache.prep_jid`` when the
        # master tries to write the ``jid`` file (issue #69418).
        #
        # Instead, we ship every state change to the master-side
        # ``BatchManager`` via ``salt/batch/<jid>/{new,progress,
        # complete,halted}`` events.  The manager — already running
        # as the master daemon's user — persists ``.batch.p`` and
        # maintains the active-batch index on the CLI's behalf.
        # ``batch.status`` / ``batch.list_active`` / ``batch.stop``
        # see sync batches because of that handoff.  All event ops
        # are best-effort: if the master event bus is unreachable
        # the CLI batch still completes correctly with no visibility.
        self._fire_event(
            salt.utils.batch_output.state_payload(state),
            salt.utils.batch_output.tag_new(batch_jid),
        )
        self._subscribe_to_halt(batch_jid)

        output = salt.utils.batch_output.CLIOutput(self.opts, quiet=self.quiet)
        for down_minion in self.down_minions:
            output.on_minion_down(down_minion)

        if self.options:
            show_jid = self.options.show_jid
            show_verbose = self.options.verbose
        else:
            show_jid = False
            show_verbose = False

        return_value = self.opts.get("return", self.opts.get("ret", ""))
        raw_mode = bool(self.opts.get("raw"))

        iters = []