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

ansible/executor/powershell/bootstrap_wrapper.ps1

@@ -1,12 +1,49 @@
-try { [Console]::InputEncoding = [Console]::OutputEncoding = New-Object System.Text.UTF8Encoding } catch { $null = $_ }
-
-if ($PSVersionTable.PSVersion -lt [Version]"3.0") {
-    '{"failed":true,"msg":"Ansible requires PowerShell v3.0 or newer"}'
+if ($PSVersionTable.PSVersion -lt [Version]"5.1") {
+    '{"failed":true,"msg":"Ansible requires PowerShell v5.1"}'
     exit 1
 }
 
-$exec_wrapper_str = $input | Out-String
-$split_parts = $exec_wrapper_str.Split(@("`0`0`0`0"), 2, [StringSplitOptions]::RemoveEmptyEntries)
-If (-not $split_parts.Length -eq 2) { throw "invalid payload" }
-Set-Variable -Name json_raw -Value $split_parts[1]
-& ([ScriptBlock]::Create($split_parts[0]))
+# First input is a JSON string with name/script/params of what to run. This
+# ends with a line of 4 null bytes and subsequent input is piped to the code
+# provided.
+$codeJson = foreach ($in in $input) {
+    if ([string]::Equals($in, "`0`0`0`0")) {
+        break
+    }
+    $in
+}
+$code = ConvertFrom-Json -InputObject $codeJson
+$splat = @{}
+foreach ($obj in $code.params.PSObject.Properties) {
+    $splat[$obj.Name] = $obj.Value
+}
+
+$filePath = $null
+try {
+    $cmd = if ($ExecutionContext.SessionState.LanguageMode -eq 'FullLanguage') {
+        # In FLM we can just invoke the code as a scriptblock without touching the
+        # disk.
+        [System.Management.Automation.Language.Parser]::ParseInput(
+            $code.script,
+            "$($code.name).ps1", # Name is used in stack traces.
+            [ref]$null,
+            [ref]$null).GetScriptBlock()
+    }
+    else {
+        # CLM needs to execute code from a file for it to run in FLM when trusted.
+        # Set-Item on 5.1 doesn't have a way to use UTF-8 without a BOM but luckily
+        # New-Item does that by default for both 5.1 and 7. We need to ensure we
+        # use UTF-8 without BOM so the signature is correct.
+        $filePath = Join-Path -Path $env:TEMP -ChildPath "$($code.name)-$(New-Guid).ps1"
+        $null = New-Item -Path $filePath -Value $code.script -ItemType File -Force
+
+        $filePath
+    }
+
+    $input | & $cmd @splat
+}
+finally {
+    if ($filePath -and (Test-Path -LiteralPath $filePath)) {
+        Remove-Item -LiteralPath $filePath -Force
+    }
+}

ansible/executor/powershell/coverage_wrapper.ps1

@@ -1,56 +1,83 @@
-# (c) 2019 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 System.Collections.Generic
+using namespace System.IO
+using namespace System.Management.Automation
+using namespace System.Management.Automation.Language
+using namespace System.Reflection
+using namespace System.Text
 
-#AnsibleRequires -Wrapper module_wrapper
+param(
+    [Parameter(Mandatory)]
+    [string]
+    $ModuleName,
 
-$ErrorActionPreference = "Stop"
+    [Parameter(Mandatory)]
+    [string]
+    $OutputPath,
 
-Write-AnsibleLog "INFO - starting coverage_wrapper" "coverage_wrapper"
+    [Parameter(Mandatory)]
+    [string]
+    $PathFilter
+)
 
-# Required to be set for psrp to we can set a breakpoint in the remote runspace
-if ($PSVersionTable.PSVersion -ge [Version]'4.0') {
-    $host.Runspace.Debugger.SetDebugMode([System.Management.Automation.DebugModes]::RemoteScript)
-}
+# Required to be set for psrp so we can set a breakpoint in the remote runspace
+$Host.Runspace.Debugger.SetDebugMode([DebugModes]::RemoteScript)
 
-Function New-CoverageBreakpoint {
+Function New-CoverageBreakpointsForScriptBlock {
     Param (
-        [String]$Path,
-        [ScriptBlock]$Code,
-        [String]$AnsiblePath
+        [Parameter(Mandatory)]
+        [string]
+        $ScriptName,
+
+        [Parameter(Mandatory)]
+        [ScriptBlockAst]
+        $ScriptBlockAst,
+
+        [Parameter(Mandatory)]
+        [String]
+        $AnsiblePath
     )
 
-    # It is quicker to pass in the code as a string instead of calling ParseFile as we already know the contents
     $predicate = {
-        $args[0] -is [System.Management.Automation.Language.CommandBaseAst]
+        $args[0] -is [CommandBaseAst]
     }
-    $script_cmds = $Code.Ast.FindAll($predicate, $true)
+    $scriptCmds = $ScriptBlockAst.FindAll($predicate, $true)
 
     # Create an object that tracks the Ansible path of the file and the breakpoints that have been set in it
     $info = [PSCustomObject]@{
         Path = $AnsiblePath
-        Breakpoints = [System.Collections.Generic.List`1[System.Management.Automation.Breakpoint]]@()
+        Breakpoints = [List[Breakpoint]]@()
+    }
+
+    # LineBreakpoint was only made public in PowerShell 6.0 so we need to use
+    # reflection to achieve the same thing in 5.1.
+    $lineCtor = if ($PSVersionTable.PSVersion -lt '6.0') {
+        [LineBreakpoint].GetConstructor(
+            [BindingFlags]'NonPublic, Instance',
+            $null,
+            [type[]]@([string], [int], [int], [scriptblock]),
+            $null)
+    }
+    else {
+        [LineBreakpoint]::new
     }
 
     # Keep track of lines that are already scanned. PowerShell can contains multiple commands in 1 line
-    $scanned_lines = [System.Collections.Generic.HashSet`1[System.Int32]]@()
-    foreach ($cmd in $script_cmds) {
-        if (-not $scanned_lines.Add($cmd.Extent.StartLineNumber)) {
+    $scannedLines = [HashSet[int]]@()
+    foreach ($cmd in $scriptCmds) {
+        if (-not $scannedLines.Add($cmd.Extent.StartLineNumber)) {
             continue
         }
 
-        # Do not add any -Action value, even if it is $null or {}. Doing so will balloon the runtime.
-        $params = @{
-            Script = $Path
-            Line = $cmd.Extent.StartLineNumber
-            Column = $cmd.Extent.StartColumnNumber
-        }
-        $info.Breakpoints.Add((Set-PSBreakpoint @params))
+        # Action is explicitly $null as it will slow down the runtime quite dramatically.
+        $b = $lineCtor.Invoke(@($ScriptName, $cmd.Extent.StartLineNumber, $cmd.Extent.StartColumnNumber, $null))
+        $info.Breakpoints.Add($b)
     }
 
+    [Runspace]::DefaultRunspace.Debugger.SetBreakpoints($info.Breakpoints)
+
     $info
 }
 
@@ -68,132 +95,61 @@ Function Compare-PathFilterPattern {
     return $false
 }
 
-$module_name = $Payload.module_args["_ansible_module_name"]
-Write-AnsibleLog "INFO - building coverage payload for '$module_name'" "coverage_wrapper"
+$actionInfo = Get-NextAnsibleAction
+$actionParams = $actionInfo.Parameters
 
-# A PS Breakpoint needs an actual path to work properly, we create a temp directory that will store the module and
-# module_util code during execution
-$temp_path = Join-Path -Path ([System.IO.Path]::GetTempPath()) -ChildPath "ansible-coverage-$([System.IO.Path]::GetRandomFileName())"
-Write-AnsibleLog "INFO - Creating temp path for coverage files '$temp_path'" "coverage_wrapper"
-New-Item -Path $temp_path -ItemType Directory > $null
-$breakpoint_info = [System.Collections.Generic.List`1[PSObject]]@()
-
-# Ensures we create files with UTF-8 encoding and a BOM. This is critical to force the powershell engine to read files
-# as UTF-8 and not as the system's codepage.
-$file_encoding = 'UTF8'
+# A PS Breakpoint needs a path to be associated with the ScriptBlock, luckily
+# the Get-AnsibleScript does this for us.
+$breakpointInfo = @()
 
 try {
-    $scripts = [System.Collections.Generic.List`1[System.Object]]@($script:common_functions)
-
-    $coverage_path_filter = $Payload.coverage.path_filter.Split(":", [StringSplitOptions]::RemoveEmptyEntries)
-
-    # We need to track what utils have already been added to the script for loading. This is because the load
-    # order is important and can have module_utils that rely on other utils.
-    $loaded_utils = [System.Collections.Generic.HashSet`1[System.String]]@()
-    $parse_util = {
-        $util_name = $args[0]
-        if (-not $loaded_utils.Add($util_name)) {
-            return
-        }
-
-        $util_code = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($Payload.powershell_modules.$util_name))
-        $util_sb = [ScriptBlock]::Create($util_code)
-        $util_path = Join-Path -Path $temp_path -ChildPath "$($util_name).psm1"
-
-        Write-AnsibleLog "INFO - Outputting module_util $util_name to temp file '$util_path'" "coverage_wrapper"
-        Set-Content -LiteralPath $util_path -Value $util_code -Encoding $file_encoding
-
-        $ansible_path = $Payload.coverage.module_util_paths.$util_name
-        if ((Compare-PathFilterPattern -Patterns $coverage_path_filter -Path $ansible_path)) {
-            $cov_params = @{
-                Path = $util_path
-                Code = $util_sb
-                AnsiblePath = $ansible_path
+    $coveragePathFilter = $PathFilter.Split(":", [StringSplitOptions]::RemoveEmptyEntries)
+    $breakpointInfo = @(
+        foreach ($scriptName in @($ModuleName; $actionParams.PowerShellModules)) {
+            # We don't use -IncludeScriptBlock as the script might be untrusted
+            # and will run under CLM. While we recreate the ScriptBlock here it
+            # is only to get the AST that contains the statements and their
+            # line numbers to create the breakpoint info for.
+            $scriptInfo = Get-AnsibleScript -Name $scriptName
+
+            if (Compare-PathFilterPattern -Patterns $coveragePathFilter -Path $scriptInfo.Path) {
+                $covParams = @{
+                    ScriptName = $scriptInfo.Name
+                    ScriptBlockAst = [ScriptBlock]::Create($scriptInfo.Script).Ast
+                    AnsiblePath = $scriptInfo.Path
+                }
+                New-CoverageBreakpointsForScriptBlock @covParams
             }
-            $breakpoints = New-CoverageBreakpoint @cov_params
-            $breakpoint_info.Add($breakpoints)
         }
+    )
 
-        if ($null -ne $util_sb.Ast.ScriptRequirements) {
-            foreach ($required_util in $util_sb.Ast.ScriptRequirements.RequiredModules) {
-                &$parse_util $required_util.Name
-            }
-        }
-        Write-AnsibleLog "INFO - Adding util $util_name to scripts to run" "coverage_wrapper"
-        $scripts.Add("Import-Module -Name '$util_path'")
-    }
-    foreach ($util in $Payload.powershell_modules.Keys) {
-        &$parse_util $util
-    }
-
-    $module = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($Payload.module_entry))
-    $module_path = Join-Path -Path $temp_path -ChildPath "$($module_name).ps1"
-    Write-AnsibleLog "INFO - Ouputting module $module_name to temp file '$module_path'" "coverage_wrapper"
-    Set-Content -LiteralPath $module_path -Value $module -Encoding $file_encoding
-    $scripts.Add($module_path)
-
-    $ansible_path = $Payload.coverage.module_path
-    if ((Compare-PathFilterPattern -Patterns $coverage_path_filter -Path $ansible_path)) {
-        $cov_params = @{
-            Path = $module_path
-            Code = [ScriptBlock]::Create($module)
-            AnsiblePath = $Payload.coverage.module_path
-        }
-        $breakpoints = New-CoverageBreakpoint @cov_params
-        $breakpoint_info.Add($breakpoints)
-    }
-
-    $variables = [System.Collections.ArrayList]@(@{ Name = "complex_args"; Value = $Payload.module_args; Scope = "Global" })
-    $entrypoint = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($payload.module_wrapper))
-    $entrypoint = [ScriptBlock]::Create($entrypoint)
-
-    $params = @{
-        Scripts = $scripts
-        Variables = $variables
-        Environment = $Payload.environment
-        ModuleName = $module_name
-    }
-    if ($breakpoint_info) {
-        $params.Breakpoints = $breakpoint_info.Breakpoints
+    if ($breakpointInfo) {
+        $actionParams.Breakpoints = $breakpointInfo.Breakpoints
     }
 
     try {
-        &$entrypoint @params
+        & $actionInfo.ScriptBlock @actionParams
     }
     finally {
         # Processing here is kept to an absolute minimum to make sure each task runtime is kept as small as
         # possible. Once all the tests have been run ansible-test will collect this info and process it locally in
         # one go.
-        Write-AnsibleLog "INFO - Creating coverage result output" "coverage_wrapper"
-        $coverage_info = @{}
-        foreach ($info in $breakpoint_info) {
-            $coverage_info.($info.Path) = $info.Breakpoints | Select-Object -Property Line, HitCount
+        $coverageInfo = @{}
+        foreach ($info in $breakpointInfo) {
+            $coverageInfo[$info.Path] = $info.Breakpoints | Select-Object -Property Line, HitCount
         }
 
-        # The coverage.output value is a filename set by the Ansible controller. We append some more remote side
-        # info to the filename to make it unique and identify the remote host a bit more.
-        $ps_version = "$($PSVersionTable.PSVersion.Major).$($PSVersionTable.PSVersion.Minor)"
-        $coverage_output_path = "$($Payload.coverage.output)=powershell-$ps_version=coverage.$($env:COMPUTERNAME).$PID.$(Get-Random)"
-        $code_cov_json = ConvertTo-Json -InputObject $coverage_info -Compress
+        $psVersion = "$($PSVersionTable.PSVersion.Major).$($PSVersionTable.PSVersion.Minor)"
+        $coverageOutputPath = "$OutputPath=powershell-$psVersion=coverage.$($env:COMPUTERNAME).$PID.$(Get-Random)"
+        $codeCovJson = ConvertTo-Json -InputObject $coverageInfo -Compress
 
-        Write-AnsibleLog "INFO - Outputting coverage json to '$coverage_output_path'" "coverage_wrapper"
         # Ansible controller expects these files to be UTF-8 without a BOM, use .NET for this.
-        $utf8_no_bom = New-Object -TypeName System.Text.UTF8Encoding -ArgumentList $false
-        [System.IO.File]::WriteAllbytes($coverage_output_path, $utf8_no_bom.GetBytes($code_cov_json))
+        $utf8 = [UTF8Encoding]::new($false)
+        [File]::WriteAllText($coverageOutputPath, $codeCovJson, $utf8)
     }
 }
 finally {
-    try {
-        if ($breakpoint_info) {
-            foreach ($b in $breakpoint_info.Breakpoints) {
-                Remove-PSBreakpoint -Breakpoint $b
-            }
-        }
-    }
-    finally {
-        Write-AnsibleLog "INFO - Remove temp coverage folder '$temp_path'" "coverage_wrapper"
-        Remove-Item -LiteralPath $temp_path -Force -Recurse
+    foreach ($b in $breakpointInfo.Breakpoints) {
+        Remove-PSBreakpoint -Breakpoint $b
     }
 }
-
-Write-AnsibleLog "INFO - ending coverage_wrapper" "coverage_wrapper"