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

ansible/plugins/connection/psrp.py

@@ -308,11 +308,13 @@ import base64
 import json
 import logging
 import os
+import shlex
 import typing as t
 
 from ansible import constants as C
 from ansible.errors import AnsibleConnectionFailure, AnsibleError
 from ansible.errors import AnsibleFileNotFound
+from ansible.executor.powershell.module_manifest import _bootstrap_powershell_script
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
 from ansible.plugins.connection import ConnectionBase
@@ -431,8 +433,10 @@ class Connection(ConnectionBase):
                                              sudoable=sudoable)
 
         pwsh_in_data: bytes | str | None = None
+        script_args: list[str] | None = None
 
-        if cmd.startswith(" ".join(_common_args) + " -EncodedCommand"):
+        common_args_prefix = " ".join(_common_args)
+        if cmd.startswith(f"{common_args_prefix} -EncodedCommand"):
             # This is a PowerShell script encoded by the shell plugin, we will
             # decode the script and execute it in the runspace instead of
             # starting a new interpreter to save on time
@@ -457,6 +461,17 @@ class Connection(ConnectionBase):
                 display.vvv("PSRP: EXEC (via pipeline wrapper)")
             else:
                 display.vvv("PSRP: EXEC %s" % script, host=self._psrp_host)
+
+        elif cmd.startswith(f"{common_args_prefix} -File "):  # trailing space is on purpose
+            # Used when executing a script file, we will execute it in the runspace process
+            # instead on a new subprocess
+            script = 'param([string]$Path, [Parameter(ValueFromRemainingArguments)][string[]]$ScriptArgs) & $Path @ScriptArgs'
+
+            # Using shlex isn't perfect but it's good enough.
+            cmd = cmd[len(common_args_prefix) + 7:]
+            script_args = shlex.split(cmd)
+            display.vvv(f"PSRP: EXEC {cmd}")
+
         else:
             # In other cases we want to execute the cmd as the script. We add on the 'exit $LASTEXITCODE' to ensure the
             # rc is propagated back to the connection plugin.
@@ -464,7 +479,11 @@ class Connection(ConnectionBase):
             pwsh_in_data = in_data
             display.vvv(u"PSRP: EXEC %s" % script, host=self._psrp_host)
 
-        rc, stdout, stderr = self._exec_psrp_script(script, pwsh_in_data)
+        rc, stdout, stderr = self._exec_psrp_script(
+            script=script,
+            input_data=pwsh_in_data.splitlines() if pwsh_in_data else None,
+            arguments=script_args,
+        )
         return rc, stdout, stderr
 
     def put_file(self, in_path: str, out_path: str) -> None:
@@ -473,101 +492,9 @@ class Connection(ConnectionBase):
         out_path = self._shell._unquote(out_path)
         display.vvv("PUT %s TO %s" % (in_path, out_path), host=self._psrp_host)
 
-        copy_script = '''begin {
-    $ErrorActionPreference = "Stop"
-    $WarningPreference = "Continue"
-    $path = $MyInvocation.UnboundArguments[0]
-    $fd = [System.IO.File]::Create($path)
-    $algo = [System.Security.Cryptography.SHA1CryptoServiceProvider]::Create()
-    $bytes = @()
-
-    $bindingFlags = [System.Reflection.BindingFlags]'NonPublic, Instance'
-    Function Get-Property {
-        <#
-        .SYNOPSIS
-        Gets the private/internal property specified of the object passed in.
-        #>
-        Param (
-            [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
-            [System.Object]
-            $Object,
-
-            [Parameter(Mandatory=$true, Position=1)]
-            [System.String]
-            $Name
-        )
-
-        $Object.GetType().GetProperty($Name, $bindingFlags).GetValue($Object, $null)
-    }
-
-    Function Set-Property {
-        <#
-        .SYNOPSIS
-        Sets the private/internal property specified on the object passed in.
-        #>
-        Param (
-            [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
-            [System.Object]
-            $Object,
-
-            [Parameter(Mandatory=$true, Position=1)]
-            [System.String]
-            $Name,
-
-            [Parameter(Mandatory=$true, Position=2)]
-            [AllowNull()]
-            [System.Object]
-            $Value
-        )
-
-        $Object.GetType().GetProperty($Name, $bindingFlags).SetValue($Object, $Value, $null)
-    }
-
-    Function Get-Field {
-        <#
-        .SYNOPSIS
-        Gets the private/internal field specified of the object passed in.
-        #>
-        Param (
-            [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
-            [System.Object]
-            $Object,
-
-            [Parameter(Mandatory=$true, Position=1)]
-            [System.String]
-            $Name
-        )
-
-        $Object.GetType().GetField($Name, $bindingFlags).GetValue($Object)
-    }
-
-    # MaximumAllowedMemory is required to be set to so we can send input data that exceeds the limit on a PS
-    # Runspace. We use reflection to access/set this property as it is not accessible publicly. This is not ideal
-    # but works on all PowerShell versions I've tested with. We originally used WinRS to send the raw bytes to the
-    # host but this falls flat if someone is using a custom PS configuration name so this is a workaround. This
-    # isn't required for smaller files so if it fails we ignore the error and hope it wasn't needed.
-    # https://github.com/PowerShell/PowerShell/blob/c8e72d1e664b1ee04a14f226adf655cced24e5f0/src/System.Management.Automation/engine/serialization.cs#L325
-    try {
-        $Host | Get-Property 'ExternalHost' | `
-            Get-Field '_transportManager' | `
-            Get-Property 'Fragmentor' | `
-            Get-Property 'DeserializationContext' | `
-            Set-Property 'MaximumAllowedMemory' $null
-    } catch {}
-}
-process {
-    $bytes = [System.Convert]::FromBase64String($input)
-    $algo.TransformBlock($bytes, 0, $bytes.Length, $bytes, 0) > $null
-    $fd.Write($bytes, 0, $bytes.Length)
-}
-end {
-    $fd.Close()
-
-    $algo.TransformFinalBlock($bytes, 0, 0) > $null
-    $hash = [System.BitConverter]::ToString($algo.Hash).Replace('-', '').ToLowerInvariant()
-    Write-Output -InputObject "{`"sha1`":`"$hash`"}"
-}
-'''
+        script, in_data = _bootstrap_powershell_script('psrp_put_file.ps1', {
+            'Path': out_path,
+        }, has_input=True)
 
         # Get the buffer size of each fragment to send, subtract 82 for the fragment, message, and other header info
         # fields that PSRP adds. Adjust to size of the base64 encoded bytes length.
@@ -580,6 +507,8 @@ end {
             raise AnsibleFileNotFound('file or module does not exist: "%s"' % to_native(in_path))
 
         def read_gen():
+            yield from in_data.decode().splitlines()
+
             offset = 0
 
             with open(b_in_path, 'rb') as src_fd:
@@ -598,7 +527,7 @@ end {
                 if offset == 0:  # empty file
                     yield [""]
 
-        rc, stdout, stderr = self._exec_psrp_script(copy_script, read_gen(), arguments=[out_path])
+        rc, stdout, stderr = self._exec_psrp_script(script, read_gen())
 
         if rc != 0:
             raise AnsibleError(to_native(stderr))
@@ -622,6 +551,7 @@ end {
 
         in_path = self._shell._unquote(in_path)
         out_path = out_path.replace('\\', '/')
+        b_out_path = to_bytes(out_path, errors='surrogate_or_strict')
 
         # because we are dealing with base64 data we need to get the max size
         # of the bytes that the base64 size would equal
@@ -629,74 +559,38 @@ end {
                            (self.runspace.connection.max_payload_size / 4 * 3))
         buffer_size = max_b64_size - (max_b64_size % 1024)
 
-        # setup the file stream with read only mode
-        setup_script = '''param([string]$Path)
-$ErrorActionPreference = "Stop"
-
-if (Test-Path -LiteralPath $path -PathType Leaf) {
-    $fs = New-Object -TypeName System.IO.FileStream -ArgumentList @(
-        $path,
-        [System.IO.FileMode]::Open,
-        [System.IO.FileAccess]::Read,
-        [System.IO.FileShare]::Read
-    )
-} elseif (Test-Path -Path $path -PathType Container) {
-    Write-Output -InputObject "[DIR]"
-} else {
-    Write-Error -Message "$path does not exist"
-    $host.SetShouldExit(1)
-}'''
-
-        # read the file stream at the offset and return the b64 string
-        read_script = '''param([int64]$Offset, [int]$BufferSize)
-$ErrorActionPreference = "Stop"
-$fs.Seek($Offset, [System.IO.SeekOrigin]::Begin) > $null
-$buffer = New-Object -TypeName byte[] -ArgumentList $BufferSize
-$read = $fs.Read($buffer, 0, $buffer.Length)
-
-if ($read -gt 0) {
-    [System.Convert]::ToBase64String($buffer, 0, $read)
-}'''
-
-        # need to run the setup script outside of the local scope so the
-        # file stream stays active between fetch operations
-        rc, stdout, stderr = self._exec_psrp_script(
-            setup_script,
-            use_local_scope=False,
-            arguments=[in_path],
-        )
-        if rc != 0:
-            raise AnsibleError("failed to setup file stream for fetch '%s': %s"
-                               % (out_path, to_native(stderr)))
-        elif stdout.strip() == '[DIR]':
-            # to be consistent with other connection plugins, we assume the caller has created the target dir
-            return
+        script, in_data = _bootstrap_powershell_script('psrp_fetch_file.ps1', {
+            'Path': in_path,
+            'BufferSize': buffer_size,
+        })
 
-        b_out_path = to_bytes(out_path, errors='surrogate_or_strict')
-        # to be consistent with other connection plugins, we assume the caller has created the target dir
-        offset = 0
-        with open(b_out_path, 'wb') as out_file:
-            while True:
-                display.vvvvv("PSRP FETCH %s to %s (offset=%d" %
-                              (in_path, out_path, offset), host=self._psrp_host)
-                rc, stdout, stderr = self._exec_psrp_script(
-                    read_script,
-                    arguments=[offset, buffer_size],
-                )
-                if rc != 0:
-                    raise AnsibleError("failed to transfer file to '%s': %s"
-                                       % (out_path, to_native(stderr)))
+        ps = PowerShell(self.runspace)
+        ps.add_script(script)
+        ps.begin_invoke(in_data.decode().splitlines())
 
-                data = base64.b64decode(stdout.strip())
-                out_file.write(data)
-                if len(data) < buffer_size:
-                    break
-                offset += len(data)
+        # Call poll once to get the first output telling us if it's a file/dir/failure
+        ps.poll_invoke()
 
-            rc, stdout, stderr = self._exec_psrp_script("$fs.Close()")
-            if rc != 0:
-                display.warning("failed to close remote file stream of file "
-                                "'%s': %s" % (in_path, to_native(stderr)))
+        if ps.output:
+            if ps.output.pop(0) == '[DIR]':
+                # to be consistent with other connection plugins, we assume the caller has created the target dir
+                return
+
+            with open(b_out_path, 'wb') as out_file:
+                while True:
+                    while ps.output:
+                        data = base64.b64decode(ps.output.pop(0))
+                        out_file.write(data)
+
+                    if ps.state == PSInvocationState.RUNNING:
+                        ps.poll_invoke()
+                    else:
+                        break
+
+        ps.end_invoke()
+        rc, stdout, stderr = self._parse_pipeline_result(ps)
+        if rc != 0:
+            raise AnsibleError(f"failed to transfer file to '{out_path}': {to_text(stderr)}")
 
     def close(self) -> None:
         if self.runspace and self.runspace.state == RunspacePoolState.OPENED:
@@ -837,6 +731,23 @@ if ($read -gt 0) {
         for error in pipeline.streams.error:
             # the error record is not as fully fleshed out like we usually get
             # in PS, we will manually create it here
+            # NativeCommandError and NativeCommandErrorMessage are special
+            # cases used for stderr from a subprocess, we will just print the
+            # error message
+            if error.fq_error == 'NativeCommandErrorMessage' and not error.target_name:
+                # This can be removed once Server 2016 is EOL and no longer
+                # supported. PS 5.1 on 2016 will emit 1 error record under
+                # NativeCommandError being the first line, subsequent records
+                # are the raw stderr up to 4096 chars. Each entry is the raw
+                # stderr value without any newlines appended so we just use the
+                # value as is. We know it's 2016 as the target_name is empty in
+                # this scenario.
+                stderr_list.append(str(error))
+                continue
+            elif error.fq_error in ['NativeCommandError', 'NativeCommandErrorMessage']:
+                stderr_list.append(f"{error}\r\n")
+                continue
+
             command_name = "%s : " % error.command_name if error.command_name else ''
             position = "%s\r\n" % error.invocation_position_message if error.invocation_position_message else ''
             error_msg = "%s%s\r\n%s" \
@@ -847,11 +758,11 @@ if ($read -gt 0) {
             stacktrace = error.script_stacktrace
             if display.verbosity >= 3 and stacktrace is not None:
                 error_msg += "\r\nStackTrace:\r\n%s" % stacktrace
-            stderr_list.append(error_msg)
+            stderr_list.append(f"{error_msg}\r\n")
 
         if len(self.host.ui.stderr) > 0:
             stderr_list += self.host.ui.stderr
-        stderr = u"\r\n".join([to_text(o) for o in stderr_list])
+        stderr = "".join([to_text(o) for o in stderr_list])
 
         display.vvvvv("PSRP RC: %d" % rc, host=self._psrp_host)
         display.vvvvv("PSRP STDOUT: %s" % stdout, host=self._psrp_host)