ansible-core 2.18.5rc1__py3-none-any.whl → 2.19.0b1__py3-none-any.whl

ansible/executor/play_iterator.py

@@ -155,9 +155,6 @@ class PlayIterator:
         setup_block.run_once = False
         setup_task = Task(block=setup_block)
         setup_task.action = 'gather_facts'
-        # TODO: hardcoded resolution here, but should use actual resolution code in the end,
-        #       in case of 'legacy' mismatch
-        setup_task.resolved_action = 'ansible.builtin.gather_facts'
         setup_task.name = 'Gathering Facts'
         setup_task.args = {}
 
@@ -255,7 +252,6 @@ class PlayIterator:
             self.set_state_for_host(host.name, s)
 
         display.debug("done getting next task for host %s" % host.name)
-        display.debug(" ^ task is: %s" % task)
         display.debug(" ^ state is: %s" % s)
         return (s, task)
 
@@ -292,7 +288,7 @@ class PlayIterator:
 
                     if (gathering == 'implicit' and implied) or \
                        (gathering == 'explicit' and boolean(self._play.gather_facts, strict=False)) or \
-                       (gathering == 'smart' and implied and not (self._variable_manager._fact_cache.get(host.name, {}).get('_ansible_facts_gathered', False))):
+                       (gathering == 'smart' and implied and not self._variable_manager._facts_gathered_for_host(host.name)):
                         # The setup block is always self._blocks[0], as we inject it
                         # during the play compilation in __init__ above.
                         setup_block = self._blocks[0]
@@ -440,7 +436,7 @@ class PlayIterator:
                     else:
                         state.cur_handlers_task += 1
                         if task.is_host_notified(host):
-                            break
+                            return state, task
 
             elif state.run_state == IteratingStates.COMPLETE:
                 return (state, None)
@@ -450,8 +446,7 @@ class PlayIterator:
                 # skip implicit flush_handlers if there are no handlers notified
                 if (
                     task.implicit
-                    and task.action in C._ACTION_META
-                    and task.args.get('_raw_params', None) == 'flush_handlers'
+                    and task._get_meta() == 'flush_handlers'
                     and (
                         # the state store in the `state` variable could be a nested state,
                         # notifications are always stored in the top level state, get it here
@@ -463,9 +458,15 @@ class PlayIterator:
                         and all(not h.notified_hosts for h in self.handlers)
                     )
                 ):
-                    continue
-
-                break
+                    display.debug("No handler notifications for %s, skipping." % host.name)
+                elif (
+                    (role := task._role)
+                    and role._metadata.allow_duplicates is False
+                    and host.name in self._play._get_cached_role(role)._completed
+                ):
+                    display.debug("'%s' skipped because role has already run" % task)
+                else:
+                    break
 
         return (state, task)
 
@@ -557,9 +558,9 @@ class PlayIterator:
             self._clear_state_errors(state.always_child_state)
 
     def get_active_state(self, state):
-        '''
+        """
         Finds the active state, recursively if necessary when there are child states.
-        '''
+        """
         if state.run_state == IteratingStates.TASKS and state.tasks_child_state is not None:
             return self.get_active_state(state.tasks_child_state)
         elif state.run_state == IteratingStates.RESCUE and state.rescue_child_state is not None:
@@ -569,10 +570,10 @@ class PlayIterator:
         return state
 
     def is_any_block_rescuing(self, state):
-        '''
+        """
         Given the current HostState state, determines if the current block, or any child blocks,
         are in rescue mode.
-        '''
+        """
         if state.run_state == IteratingStates.TASKS and state.get_current_block().rescue:
             return True
         if state.tasks_child_state is not None:
@@ -592,28 +593,22 @@ class PlayIterator:
             if state.tasks_child_state:
                 state.tasks_child_state = self._insert_tasks_into_state(state.tasks_child_state, task_list)
             else:
-                target_block = state._blocks[state.cur_block].copy()
-                before = target_block.block[:state.cur_regular_task]
-                after = target_block.block[state.cur_regular_task:]
-                target_block.block = before + task_list + after
+                target_block = state._blocks[state.cur_block].copy(exclude_tasks=True)
+                target_block.block[state.cur_regular_task:state.cur_regular_task] = task_list
                 state._blocks[state.cur_block] = target_block
         elif state.run_state == IteratingStates.RESCUE:
             if state.rescue_child_state:
                 state.rescue_child_state = self._insert_tasks_into_state(state.rescue_child_state, task_list)
             else:
-                target_block = state._blocks[state.cur_block].copy()
-                before = target_block.rescue[:state.cur_rescue_task]
-                after = target_block.rescue[state.cur_rescue_task:]
-                target_block.rescue = before + task_list + after
+                target_block = state._blocks[state.cur_block].copy(exclude_tasks=True)
+                target_block.rescue[state.cur_rescue_task:state.cur_rescue_task] = task_list
                 state._blocks[state.cur_block] = target_block
         elif state.run_state == IteratingStates.ALWAYS:
             if state.always_child_state:
                 state.always_child_state = self._insert_tasks_into_state(state.always_child_state, task_list)
             else:
-                target_block = state._blocks[state.cur_block].copy()
-                before = target_block.always[:state.cur_always_task]
-                after = target_block.always[state.cur_always_task:]
-                target_block.always = before + task_list + after
+                target_block = state._blocks[state.cur_block].copy(exclude_tasks=True)
+                target_block.always[state.cur_always_task:state.cur_always_task] = task_list
                 state._blocks[state.cur_block] = target_block
         elif state.run_state == IteratingStates.HANDLERS:
             state.handlers[state.cur_handlers_task:state.cur_handlers_task] = [h for b in task_list for h in b.block]

ansible/executor/playbook_executor.py

@@ -26,7 +26,7 @@ from ansible.module_utils.common.text.converters import to_text
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.loader import become_loader, connection_loader, shell_loader
 from ansible.playbook import Playbook
-from ansible.template import Templar
+from ansible._internal._templating._engine import TemplateEngine
 from ansible.utils.helpers import pct_to_int
 from ansible.utils.collection_loader import AnsibleCollectionConfig
 from ansible.utils.collection_loader._collection_finder import _get_collection_name_from_path, _get_collection_playbook_path
@@ -40,10 +40,10 @@ display = Display()
 
 class PlaybookExecutor:
 
-    '''
+    """
     This is the primary class for executing playbooks, and thus the
     basis for bin/ansible-playbook operation.
-    '''
+    """
 
     def __init__(self, playbooks, inventory, variable_manager, loader, passwords):
         self._playbooks = playbooks
@@ -74,10 +74,10 @@ class PlaybookExecutor:
         set_default_transport()
 
     def run(self):
-        '''
+        """
         Run the given playbook, based on the settings in the play which
         may limit the runs to serialized groups, etc.
-        '''
+        """
 
         result = 0
         entrylist = []
@@ -132,7 +132,7 @@ class PlaybookExecutor:
 
                     # Allow variables to be used in vars_prompt fields.
                     all_vars = self._variable_manager.get_vars(play=play)
-                    templar = Templar(loader=self._loader, variables=all_vars)
+                    templar = TemplateEngine(loader=self._loader, variables=all_vars)
                     setattr(play, 'vars_prompt', templar.template(play.vars_prompt))
 
                     # FIXME: this should be a play 'sub object' like loop_control
@@ -158,7 +158,7 @@ class PlaybookExecutor:
 
                     # Post validate so any play level variables are templated
                     all_vars = self._variable_manager.get_vars(play=play)
-                    templar = Templar(loader=self._loader, variables=all_vars)
+                    templar = TemplateEngine(loader=self._loader, variables=all_vars)
                     play.post_validate(templar)
 
                     if context.CLIARGS['syntax']:
@@ -267,10 +267,10 @@ class PlaybookExecutor:
         return result
 
     def _get_serialized_batches(self, play):
-        '''
+        """
         Returns a list of hosts, subdivided into batches based on
         the serial size specified in the play.
-        '''
+        """
 
         # make sure we have a unique list of hosts
         all_hosts = self._inventory.get_hosts(play.hosts, order=play.order)
@@ -313,11 +313,11 @@ class PlaybookExecutor:
         return serialized_batches
 
     def _generate_retry_inventory(self, retry_path, replay_hosts):
-        '''
+        """
         Called when a playbook run fails. It generates an inventory which allows
         re-running on ONLY the failed hosts.  This may duplicate some variable
         information in group_vars/host_vars but that is ok, and expected.
-        '''
+        """
         try:
             makedirs_safe(os.path.dirname(retry_path))
             with open(retry_path, 'w') as fd:

ansible/executor/powershell/async_watchdog.ps1

@@ -1,117 +1,112 @@
-# (c) 2018 Ansible Project
+# (c) 2025 Ansible Project
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
-param(
-    [Parameter(Mandatory = $true)][System.Collections.IDictionary]$Payload
+using namespace Microsoft.Win32.SafeHandles
+using namespace System.Collections
+using namespace System.IO
+using namespace System.Management.Automation
+using namespace System.Text
+using namespace System.Threading
+
+[CmdletBinding()]
+param (
+    [Parameter(Mandatory)]
+    [string]
+    $ResultPath,
+
+    [Parameter(Mandatory)]
+    [int]
+    $Timeout,
+
+    [Parameter(Mandatory)]
+    [Int64]
+    $WaitHandleId
 )
 
-# help with debugging errors as we don't have visibility of this running process
-trap {
-    $watchdog_path = "$($env:TEMP)\ansible-async-watchdog-error-$(Get-Date -Format "yyyy-MM-ddTHH-mm-ss.ffffZ").txt"
-    $error_msg = "Error while running the async exec wrapper`r`n$(Format-AnsibleException -ErrorRecord $_)"
-    Set-Content -Path $watchdog_path -Value $error_msg
-    break
+if (-not (Test-Path -LiteralPath $ResultPath)) {
+    throw "async result file at '$ResultPath' does not exist"
 }
+$result = Get-Content -LiteralPath $ResultPath | ConvertFrom-Json | Convert-JsonObject
 
-$ErrorActionPreference = "Stop"
-
-Write-AnsibleLog "INFO - starting async_watchdog" "async_watchdog"
-
-# pop 0th action as entrypoint
-$payload.actions = $payload.actions[1..99]
-
-$actions = $Payload.actions
-$entrypoint = $payload.($actions[0])
-$entrypoint = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($entrypoint))
-
-$resultfile_path = $payload.async_results_path
-$max_exec_time_sec = $payload.async_timeout_sec
-
-Write-AnsibleLog "INFO - deserializing existing result file args at: '$resultfile_path'" "async_watchdog"
-if (-not (Test-Path -Path $resultfile_path)) {
-    $msg = "result file at '$resultfile_path' does not exist"
-    Write-AnsibleLog "ERROR - $msg" "async_watchdog"
-    throw $msg
-}
-$result_json = Get-Content -Path $resultfile_path -Raw
-Write-AnsibleLog "INFO - result file json is: $result_json" "async_watchdog"
-$result = ConvertFrom-AnsibleJson -InputObject $result_json
-
-Write-AnsibleLog "INFO - creating async runspace" "async_watchdog"
-$rs = [RunspaceFactory]::CreateRunspace()
-$rs.Open()
-
-Write-AnsibleLog "INFO - creating async PowerShell pipeline" "async_watchdog"
+# The intermediate script is used so that things are set up like it normally
+# is. The new Runspace is used to ensure we can stop it once the async time is
+# exceeded.
+$execInfo = Get-AnsibleExecWrapper -ManifestAsParam -IncludeScriptBlock
 $ps = [PowerShell]::Create()
-$ps.Runspace = $rs
-
-# these functions are set in exec_wrapper
-Write-AnsibleLog "INFO - adding global functions to PowerShell pipeline script" "async_watchdog"
-$ps.AddScript($script:common_functions).AddStatement() > $null
-$ps.AddScript($script:wrapper_functions).AddStatement() > $null
-$function_params = @{
-    Name = "common_functions"
-    Value = $script:common_functions
-    Scope = "script"
+$null = $ps.AddScript(@'
+[CmdletBinding()]
+param([ScriptBlock]$ScriptBlock, $Param)
+
+& $ScriptBlock.Ast.GetScriptBlock() @Param
+'@).AddParameters(
+    @{
+        ScriptBlock = $execInfo.ScriptBlock
+        Param = $execInfo.Parameters
+    })
+
+# It is important we run with the invocation settings so that it has access
+# to the same PSHost. The pipeline input also needs to be marked as complete
+# so the exec_wrapper isn't waiting for input indefinitely.
+$pipelineInput = [PSDataCollection[object]]::new()
+$pipelineInput.Complete()
+$invocationSettings = [PSInvocationSettings]@{
+    Host = $host
 }
-$ps.AddCommand("Set-Variable").AddParameters($function_params).AddStatement() > $null
-
-Write-AnsibleLog "INFO - adding $($actions[0]) to PowerShell pipeline script" "async_watchdog"
-$ps.AddScript($entrypoint).AddArgument($payload) > $null
-
-Write-AnsibleLog "INFO - async job start, calling BeginInvoke()" "async_watchdog"
-$job_async_result = $ps.BeginInvoke()
-
-Write-AnsibleLog "INFO - waiting '$max_exec_time_sec' seconds for async job to complete" "async_watchdog"
-$job_async_result.AsyncWaitHandle.WaitOne($max_exec_time_sec * 1000) > $null
-$result.finished = 1
 
-if ($job_async_result.IsCompleted) {
-    Write-AnsibleLog "INFO - async job completed, calling EndInvoke()" "async_watchdog"
-
-    $job_output = $ps.EndInvoke($job_async_result)
-    $job_error = $ps.Streams.Error
-
-    Write-AnsibleLog "INFO - raw module stdout:`r`n$($job_output | Out-String)" "async_watchdog"
-    if ($job_error) {
-        Write-AnsibleLog "WARN - raw module stderr:`r`n$($job_error | Out-String)" "async_watchdog"
-    }
-
-    # write success/output/error to result object
-    # TODO: cleanse leading/trailing junk
-    try {
-        Write-AnsibleLog "INFO - deserializing Ansible stdout" "async_watchdog"
-        $module_result = ConvertFrom-AnsibleJson -InputObject $job_output
+# Signals async_wrapper that we are ready to start the job and to stop waiting
+$waitHandle = [SafeWaitHandle]::new([IntPtr]$WaitHandleId, $true)
+$waitEvent = [ManualResetEvent]::new($false)
+$waitEvent.SafeWaitHandle = $waitHandle
+$null = $waitEvent.Set()
+
+$jobOutput = $null
+$jobError = $null
+try {
+    $jobAsyncResult = $ps.BeginInvoke($pipelineInput, $invocationSettings, $null, $null)
+    $jobAsyncResult.AsyncWaitHandle.WaitOne($Timeout * 1000) > $null
+    $result.finished = 1
+
+    if ($jobAsyncResult.IsCompleted) {
+        $jobOutput = $ps.EndInvoke($jobAsyncResult)
+        $jobError = $ps.Streams.Error
+
+        # write success/output/error to result object
+        # TODO: cleanse leading/trailing junk
+        $moduleResult = $jobOutput | ConvertFrom-Json | Convert-JsonObject
         # TODO: check for conflicting keys
-        $result = $result + $module_result
-    }
-    catch {
-        $result.failed = $true
-        $result.msg = "failed to parse module output: $($_.Exception.Message)"
-        # return output back to Ansible to help with debugging errors
-        $result.stdout = $job_output | Out-String
-        $result.stderr = $job_error | Out-String
+        $result = $result + $moduleResult
     }
+    else {
+        # We can't call Stop() as pwsh won't respond if it is busy calling a .NET
+        # method. The process end will shut everything down instead.
+        $ps.BeginStop($null, $null)  > $null
 
-    $result_json = ConvertTo-Json -InputObject $result -Depth 99 -Compress
-    Set-Content -Path $resultfile_path -Value $result_json
-
-    Write-AnsibleLog "INFO - wrote output to $resultfile_path" "async_watchdog"
+        throw "timed out waiting for module completion"
+    }
 }
-else {
-    Write-AnsibleLog "ERROR - reached timeout on async job, stopping job" "async_watchdog"
-    $ps.BeginStop($null, $null)  > $null # best effort stop
-
-    # write timeout to result object
+catch {
+    $exception = @(
+        "$_"
+        "$($_.InvocationInfo.PositionMessage)"
+        "+ CategoryInfo          : $($_.CategoryInfo)"
+        "+ FullyQualifiedErrorId : $($_.FullyQualifiedErrorId)"
+        ""
+        "ScriptStackTrace:"
+        "$($_.ScriptStackTrace)"
+
+        if ($_.Exception.StackTrace) {
+            "$($_.Exception.StackTrace)"
+        }
+    ) -join ([Environment]::NewLine)
+
+    $result.exception = $exception
     $result.failed = $true
-    $result.msg = "timed out waiting for module completion"
-    $result_json = ConvertTo-Json -InputObject $result -Depth 99 -Compress
-    Set-Content -Path $resultfile_path -Value $result_json
-
-    Write-AnsibleLog "INFO - wrote timeout to '$resultfile_path'" "async_watchdog"
+    $result.msg = "failure during async watchdog: $_"
+    # return output back, if available, to Ansible to help with debugging errors
+    $result.stdout = $jobOutput | Out-String
+    $result.stderr = $jobError | Out-String
+}
+finally {
+    $resultJson = ConvertTo-Json -InputObject $result -Depth 99 -Compress
+    Set-Content -LiteralPath $ResultPath -Value $resultJson -Encoding UTF8
 }
-
-# in the case of a hung pipeline, this will cause the process to stay alive until it's un-hung...
-#$rs.Close() | Out-Null
-
-Write-AnsibleLog "INFO - ending async_watchdog" "async_watchdog"