ansible-core 2.18.7rc1__py3-none-any.whl → 2.19.0__py3-none-any.whl

ansible/executor/powershell/winrm_put_file.ps1

@@ -0,0 +1,36 @@
+# (c) 2025 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+using namespace System.IO
+using namespace System.Security.Cryptography
+
+[CmdletBinding()]
+param (
+    [Parameter(Mandatory)]
+    [string]
+    $Path,
+
+    [Parameter(ValueFromPipeline)]
+    [string]
+    $InputObject
+)
+
+begin {
+    $fd = [File]::Create($Path)
+    $sha1 = [SHA1]::Create()
+    $bytes = @() #initialize for empty file case
+}
+
+process {
+    $bytes = [Convert]::FromBase64String($InputObject)
+    $null = $sha1.TransformBlock($bytes, 0, $bytes.Length, $bytes, 0)
+    $fd.Write($bytes, 0, $bytes.Length)
+}
+
+end {
+    $fd.Dispose()
+    $null = $sha1.TransformFinalBlock($bytes, 0, 0)
+    $hash = [BitConverter]::ToString($sha1.Hash).Replace("-", "").ToLowerInvariant()
+
+    '{{"sha1":"{0}"}}' -f $hash
+}

ansible/executor/process/worker.py

@@ -17,18 +17,32 @@
 
 from __future__ import annotations
 
+import io
 import os
+import signal
 import sys
+import textwrap
 import traceback
+import types
+import typing as t
 
-from jinja2.exceptions import TemplateNotFound
 from multiprocessing.queues import Queue
 
-from ansible.errors import AnsibleConnectionFailure, AnsibleError
+from ansible._internal import _task
+from ansible._internal._errors import _error_utils
+from ansible.errors import AnsibleError
 from ansible.executor.task_executor import TaskExecutor
+from ansible.executor.task_queue_manager import FinalQueue, STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO
+from ansible.executor.task_result import _RawTaskResult
+from ansible.inventory.host import Host
 from ansible.module_utils.common.text.converters import to_text
+from ansible.parsing.dataloader import DataLoader
+from ansible.playbook.task import Task
+from ansible.playbook.play_context import PlayContext
+from ansible.utils.context_objects import CLIArgs
 from ansible.utils.display import Display
 from ansible.utils.multiprocessing import context as multiprocessing_context
+from ansible.vars.manager import VariableManager
 
 __all__ = ['WorkerProcess']
 
@@ -47,13 +61,26 @@ class WorkerQueue(Queue):
 
 
 class WorkerProcess(multiprocessing_context.Process):  # type: ignore[name-defined]
-    '''
+    """
     The worker thread class, which uses TaskExecutor to run tasks
     read from a job queue and pushes results into a results queue
     for reading later.
-    '''
-
-    def __init__(self, final_q, task_vars, host, task, play_context, loader, variable_manager, shared_loader_obj, worker_id):
+    """
+
+    def __init__(
+            self,
+            *,
+            final_q: FinalQueue,
+            task_vars: dict,
+            host: Host,
+            task: Task,
+            play_context: PlayContext,
+            loader: DataLoader,
+            variable_manager: VariableManager,
+            shared_loader_obj: types.SimpleNamespace,
+            worker_id: int,
+            cliargs: CLIArgs
+    ) -> None:
 
         super(WorkerProcess, self).__init__()
         # takes a task queue manager as the sole param:
@@ -73,60 +100,82 @@ class WorkerProcess(multiprocessing_context.Process):  # type: ignore[name-defin
         self.worker_queue = WorkerQueue(ctx=multiprocessing_context)
         self.worker_id = worker_id
 
-    def _save_stdin(self):
-        self._new_stdin = None
-        try:
-            if sys.stdin.isatty() and sys.stdin.fileno() is not None:
-                try:
-                    self._new_stdin = os.fdopen(os.dup(sys.stdin.fileno()))
-                except OSError:
-                    # couldn't dupe stdin, most likely because it's
-                    # not a valid file descriptor
-                    pass
-        except (AttributeError, ValueError):
-            # couldn't get stdin's fileno
-            pass
+        self._cliargs = cliargs
 
-        if self._new_stdin is None:
-            self._new_stdin = open(os.devnull)
+    def _term(self, signum, frame) -> None:
+        """
+        terminate the process group created by calling setsid when
+        a terminate signal is received by the fork
+        """
+        os.killpg(self.pid, signum)
 
-    def start(self):
-        '''
+    def start(self) -> None:
+        """
         multiprocessing.Process replaces the worker's stdin with a new file
         but we wish to preserve it if it is connected to a terminal.
         Therefore dup a copy prior to calling the real start(),
         ensuring the descriptor is preserved somewhere in the new child, and
         make sure it is closed in the parent when start() completes.
-        '''
+        """
 
-        self._save_stdin()
         # FUTURE: this lock can be removed once a more generalized pre-fork thread pause is in place
         with display._lock:
-            try:
-                return super(WorkerProcess, self).start()
-            finally:
-                self._new_stdin.close()
-
-    def _hard_exit(self, e):
-        '''
+            super(WorkerProcess, self).start()
+        # Since setsid is called later, if the worker is termed
+        # it won't term the new process group
+        # register a handler to propagate the signal
+        signal.signal(signal.SIGTERM, self._term)
+        signal.signal(signal.SIGINT, self._term)
+
+    def _hard_exit(self, e: str) -> t.NoReturn:
+        """
         There is no safe exception to return to higher level code that does not
         risk an innocent try/except finding itself executing in the wrong
         process. All code executing above WorkerProcess.run() on the stack
         conceptually belongs to another program.
-        '''
+        """
 
         try:
             display.debug(u"WORKER HARD EXIT: %s" % to_text(e))
         except BaseException:
-            # If the cause of the fault is IOError being generated by stdio,
-            # attempting to log a debug message may trigger another IOError.
+            # If the cause of the fault is OSError being generated by stdio,
+            # attempting to log a debug message may trigger another OSError.
             # Try printing once then give up.
             pass
 
         os._exit(1)
 
-    def run(self):
-        '''
+    def _detach(self) -> None:
+        """
+        The intent here is to detach the child process from the inherited stdio fds,
+        including /dev/tty. Children should use Display instead of direct interactions
+        with stdio fds.
+        """
+        try:
+            os.setsid()
+            # Create new fds for stdin/stdout/stderr, but also capture python uses of sys.stdout/stderr
+            for fds, mode in (
+                    ((STDIN_FILENO,), os.O_RDWR | os.O_NONBLOCK),
+                    ((STDOUT_FILENO, STDERR_FILENO), os.O_WRONLY),
+            ):
+                stdio = os.open(os.devnull, mode)
+                for fd in fds:
+                    os.dup2(stdio, fd)
+                os.close(stdio)
+            sys.stdout = io.StringIO()
+            sys.stderr = io.StringIO()
+            sys.stdin = os.fdopen(STDIN_FILENO, 'r', closefd=False)
+            # Close stdin so we don't get hanging workers
+            # We use sys.stdin.close() for places where sys.stdin is used,
+            # to give better errors, and to prevent fd 0 reuse
+            sys.stdin.close()
+        except Exception as e:
+            display.debug(f'Could not detach from stdio: {traceback.format_exc()}')
+            display.error(f'Could not detach from stdio: {e}')
+            os._exit(1)
+
+    def run(self) -> None:
+        """
         Wrap _run() to ensure no possibility an errant exception can cause
         control to return to the StrategyBase task loop, or any other code
         higher in the stack.
@@ -134,125 +183,66 @@ class WorkerProcess(multiprocessing_context.Process):  # type: ignore[name-defin
         As multiprocessing in Python 2.x provides no protection, it is possible
         a try/except added in far-away code can cause a crashed child process
         to suddenly assume the role and prior state of its parent.
-        '''
+        """
+        # Set the queue on Display so calls to Display.display are proxied over the queue
+        display.set_queue(self._final_q)
+        self._detach()
         try:
-            return self._run()
-        except BaseException as e:
-            self._hard_exit(e)
-        finally:
-            # This is a hack, pure and simple, to work around a potential deadlock
-            # in ``multiprocessing.Process`` when flushing stdout/stderr during process
-            # shutdown.
-            #
-            # We should no longer have a problem with ``Display``, as it now proxies over
-            # the queue from a fork. However, to avoid any issues with plugins that may
-            # be doing their own printing, this has been kept.
-            #
-            # This happens at the very end to avoid that deadlock, by simply side
-            # stepping it. This should not be treated as a long term fix.
-            #
-            # TODO: Evaluate migrating away from the ``fork`` multiprocessing start method.
-            sys.stdout = sys.stderr = open(os.devnull, 'w')
-
-    def _run(self):
-        '''
+            with _task.TaskContext(self._task):
+                return self._run()
+        except BaseException:
+            self._hard_exit(traceback.format_exc())
+
+    def _run(self) -> None:
+        """
         Called when the process is started.  Pushes the result onto the
         results queue. We also remove the host from the blocked hosts list, to
         signify that they are ready for their next task.
-        '''
-
-        # import cProfile, pstats, StringIO
-        # pr = cProfile.Profile()
-        # pr.enable()
-
-        # Set the queue on Display so calls to Display.display are proxied over the queue
-        display.set_queue(self._final_q)
+        """
 
         global current_worker
+
         current_worker = self
 
-        try:
-            # execute the task and build a TaskResult from the result
-            display.debug("running TaskExecutor() for %s/%s" % (self._host, self._task))
-            executor_result = TaskExecutor(
-                self._host,
-                self._task,
-                self._task_vars,
-                self._play_context,
-                self._new_stdin,
-                self._loader,
-                self._shared_loader_obj,
-                self._final_q,
-                self._variable_manager,
-            ).run()
-
-            display.debug("done running TaskExecutor() for %s/%s [%s]" % (self._host, self._task, self._task._uuid))
-            self._host.vars = dict()
-            self._host.groups = []
-
-            # put the result on the result queue
-            display.debug("sending task result for task %s" % self._task._uuid)
-            try:
-                self._final_q.send_task_result(
-                    self._host.name,
-                    self._task._uuid,
-                    executor_result,
-                    task_fields=self._task.dump_attrs(),
+        executor_result = TaskExecutor(
+            self._host,
+            self._task,
+            self._task_vars,
+            self._play_context,
+            self._loader,
+            self._shared_loader_obj,
+            self._final_q,
+            self._variable_manager,
+        ).run()
+
+        self._host.vars = dict()
+        self._host.groups = []
+
+        for name, stdio in (('stdout', sys.stdout), ('stderr', sys.stderr)):
+            if data := stdio.getvalue():  # type: ignore[union-attr]
+                display.warning(
+                    (
+                        f'WorkerProcess for [{self._host}/{self._task}] errantly sent data directly to {name} instead of using Display:\n'
+                        f'{textwrap.indent(data[:256], "    ")}\n'
+                    ),
+                    formatted=True
                 )
-            except Exception as e:
-                display.debug(f'failed to send task result ({e}), sending surrogate result')
-                self._final_q.send_task_result(
-                    self._host.name,
-                    self._task._uuid,
-                    # Overriding the task result, to represent the failure
-                    {
-                        'failed': True,
-                        'msg': f'{e}',
-                        'exception': traceback.format_exc(),
-                    },
-                    # The failure pickling may have been caused by the task attrs, omit for safety
-                    {},
-                )
-            display.debug("done sending task result for task %s" % self._task._uuid)
-
-        except AnsibleConnectionFailure:
-            self._host.vars = dict()
-            self._host.groups = []
-            self._final_q.send_task_result(
-                self._host.name,
-                self._task._uuid,
-                dict(unreachable=True),
-                task_fields=self._task.dump_attrs(),
-            )
 
-        except Exception as e:
-            if not isinstance(e, (IOError, EOFError, KeyboardInterrupt, SystemExit)) or isinstance(e, TemplateNotFound):
-                try:
-                    self._host.vars = dict()
-                    self._host.groups = []
-                    self._final_q.send_task_result(
-                        self._host.name,
-                        self._task._uuid,
-                        dict(failed=True, exception=to_text(traceback.format_exc()), stdout=''),
-                        task_fields=self._task.dump_attrs(),
-                    )
-                except Exception:
-                    display.debug(u"WORKER EXCEPTION: %s" % to_text(e))
-                    display.debug(u"WORKER TRACEBACK: %s" % to_text(traceback.format_exc()))
-                finally:
-                    self._clean_up()
-
-        display.debug("WORKER PROCESS EXITING")
-
-        # pr.disable()
-        # s = StringIO.StringIO()
-        # sortby = 'time'
-        # ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
-        # ps.print_stats()
-        # with open('worker_%06d.stats' % os.getpid(), 'w') as f:
-        #     f.write(s.getvalue())
-
-    def _clean_up(self):
-        # NOTE: see note in init about forks
-        # ensure we cleanup all temp files for this worker
-        self._loader.cleanup_all_tmp_files()
+        try:
+            self._final_q.send_task_result(_RawTaskResult(
+                host=self._host,
+                task=self._task,
+                return_data=executor_result,
+                task_fields=self._task.dump_attrs(),
+            ))
+        except Exception as ex:
+            try:
+                raise AnsibleError("Task result omitted due to queue send failure.") from ex
+            except Exception as ex_wrapper:
+                self._final_q.send_task_result(_RawTaskResult(
+                    host=self._host,
+                    task=self._task,
+                    # ignore the real task result and don't allow result object contribution from the exception (in case the pickling error was related)
+                    return_data=_error_utils.result_dict_from_exception(ex_wrapper),
+                    task_fields={},  # The failure pickling may have been caused by the task attrs, omit for safety
+                ))

ansible/executor/stats.py

@@ -23,7 +23,7 @@ from ansible.utils.vars import merge_hash
 
 
 class AggregateStats:
-    ''' holds stats about per-host activity during playbook runs '''
+    """ holds stats about per-host activity during playbook runs """
 
     def __init__(self):
 
@@ -40,7 +40,7 @@ class AggregateStats:
         self.custom = {}
 
     def increment(self, what, host):
-        ''' helper function to bump a statistic '''
+        """ helper function to bump a statistic """
 
         self.processed[host] = 1
         prev = (getattr(self, what)).get(host, 0)
@@ -57,7 +57,7 @@ class AggregateStats:
             _what[host] = 0
 
     def summarize(self, host):
-        ''' return information about a particular host '''
+        """ return information about a particular host """
 
         return dict(
             ok=self.ok.get(host, 0),
@@ -70,7 +70,7 @@ class AggregateStats:
         )
 
     def set_custom_stats(self, which, what, host=None):
-        ''' allow setting of a custom stat'''
+        """ allow setting of a custom stat"""
 
         if host is None:
             host = '_run'
@@ -80,7 +80,7 @@ class AggregateStats:
             self.custom[host][which] = what
 
     def update_custom_stats(self, which, what, host=None):
-        ''' allow aggregation of a custom stat'''
+        """ allow aggregation of a custom stat"""
 
         if host is None:
             host = '_run'