Coverage for lib/ansible/plugins/shell/powershell.py: 24%

$exec_args = New-Object System.Text.StringBuilder @("`"$exec_cmd`" -NonInteractive -NoProfile -ExecutionPolicy Bypass -EncodedCommand $encoded_command")

# TODO: use proper Win32Exception + error

If(-not [Ansible.Async.NativeProcessUtil]::CreateProcess($exec_cmd, $exec_args,

[IntPtr]::Zero, [IntPtr]::Zero, $true, $pstartup_flags, [IntPtr]::Zero, $env:windir, $si, [ref]$pi)) {

#throw New-Object System.ComponentModel.Win32Exception

throw "Worker creation failed, Win32Error: $([System.Runtime.InteropServices.Marshal]::GetLastWin32Error())"

}

# FUTURE: watch process for quick exit, capture stdout/stderr and return failure

$watchdog_pid = $pi.dwProcessId

[Ansible.Async.NativeProcessUtil]::ResumeProcessById($watchdog_pid)

# once process is resumed, we can send payload over stdin

$payload_string = $payload | ConvertTo-Json -Depth 99 -Compress

$stdin.WriteLine($payload_string)

$stdin.Close()

# populate initial results before we resume the process to avoid result race

$result = @{

started=1;

finished=0;

results_file=$results_path;

ansible_job_id=$local_jid;

_ansible_suppress_tmpdir_delete=$true;

ansible_async_watchdog_pid=$watchdog_pid

}

$result_json = ConvertTo-Json $result

Set-Content $results_path -Value $result_json

return $result_json

}

''' # end async_wrapper

async_watchdog = br'''

Set-StrictMode -Version 2

$ErrorActionPreference = "Stop"

Add-Type -AssemblyName System.Web.Extensions

Function Log {

Param(

[string]$msg

)

If(Get-Variable -Name log_path -ErrorAction SilentlyContinue) {

Add-Content $log_path $msg

}

Function Deserialize-Json {

Param(

[Parameter(ValueFromPipeline=$true)]

[string]$json

)

# FUTURE: move this into module_utils/powershell.ps1 and use for everything (sidestep PSCustomObject issues)

# FUTURE: won't work w/ Nano Server/.NET Core- fallback to DataContractJsonSerializer (which can't handle dicts on .NET 4.0)

Log "Deserializing:`n$json"

$jss = New-Object System.Web.Script.Serialization.JavaScriptSerializer

return $jss.DeserializeObject($json)

}

Function Write-Result {

Param(

[hashtable]$result,

[string]$resultfile_path

)

$result | ConvertTo-Json | Set-Content -Path $resultfile_path

}

Function Run($payload) {

$actions = $payload.actions

# pop 0th action as entrypoint

$entrypoint = $payload.($actions[0])

$entrypoint = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($entrypoint))

$payload.actions = $payload.actions[1..99]

$resultfile_path = $payload.async_results_path

$max_exec_time_sec = $payload.async_timeout_sec

Log "deserializing existing resultfile args"

# read in existing resultsfile to merge w/ module output (it should be written by the time we're unsuspended and running)

$result = Get-Content $resultfile_path -Raw | Deserialize-Json

Log "deserialized result is $($result | Out-String)"

Log "creating runspace"

$rs = [runspacefactory]::CreateRunspace()

$rs.Open()

Log "creating Powershell object"

$job = [powershell]::Create()

$job.Runspace = $rs

$job.AddScript($entrypoint) | Out-Null

$job.AddStatement().AddCommand("Run").AddArgument($payload) | Out-Null

Log "job BeginInvoke()"

$job_asyncresult = $job.BeginInvoke()

Log "waiting $max_exec_time_sec seconds for job to complete"

$signaled = $job_asyncresult.AsyncWaitHandle.WaitOne($max_exec_time_sec * 1000)

$result["finished"] = 1

If($job_asyncresult.IsCompleted) {

Log "job completed, calling EndInvoke()"

$job_output = $job.EndInvoke($job_asyncresult)

$job_error = $job.Streams.Error

Log "raw module stdout: \r\n$job_output"

If($job_error) {

Log "raw module stderr: \r\n$job_error"

}

# write success/output/error to result object

# TODO: cleanse leading/trailing junk

Try {

$module_result = Deserialize-Json $job_output

# TODO: check for conflicting keys

$result = $result + $module_result

}

Catch {

$excep = $_

$result.failed = $true

$result.msg = "failed to parse module output: $excep"

}

# TODO: determine success/fail, or always include stderr if nonempty?

Write-Result $result $resultfile_path

Log "wrote output to $resultfile_path"

}

Else {

$job.BeginStop($null, $null) | Out-Null # best effort stop

# write timeout to result object

$result.failed = $true

$result.msg = "timed out waiting for module completion"

Write-Result $result $resultfile_path

Log "wrote timeout to $resultfile_path"

}

# in the case of a hung pipeline, this will cause the process to stay alive until it's un-hung...

#$rs.Close() | Out-Null

}

''' # end async_watchdog

from ansible.plugins import AnsiblePlugin

class ShellModule(ShellBase):

# Common shell filenames that this plugin handles

# Powershell is handled differently. It's selected when winrm is the

# connection

COMPATIBLE_SHELLS = frozenset()

# Family of shells this has. Must match the filename without extension

SHELL_FAMILY = 'powershell'

env = dict()

# We're being overly cautious about which keys to accept (more so than

# the Windows environment is capable of doing), since the powershell

# env provider's limitations don't appear to be documented.

safe_envkey = re.compile(r'^[\d\w_]{1,255}$')

# TODO: add binary module support

def assert_safe_env_key(self, key):

if not self.safe_envkey.match(key):

raise AnsibleError("Invalid PowerShell environment key: %s" % key)

return key

def safe_env_value(self, key, value):

if len(value) > 32767:

raise AnsibleError("PowerShell environment value for key '%s' exceeds 32767 characters in length" % key)

# powershell single quoted literals need single-quote doubling as their only escaping

value = value.replace("'", "''")

return to_text(value, errors='surrogate_or_strict')

def env_prefix(self, **kwargs):

# powershell/winrm env handling is handled in the exec wrapper

return ""

def join_path(self, *args):

parts = []

for arg in args:

arg = self._unquote(arg).replace('/', '\\')

parts.extend([a for a in arg.split('\\') if a])

path = '\\'.join(parts)

if path.startswith('~'):

return path

return '\'%s\'' % path

def get_remote_filename(self, pathname):

# powershell requires that script files end with .ps1

base_name = os.path.basename(pathname.strip())

name, ext = os.path.splitext(base_name.strip())

if ext.lower() not in ['.ps1', '.exe']:

return name + '.ps1'

return base_name.strip()

def path_has_trailing_slash(self, path):

# Allow Windows paths to be specified using either slash.

path = self._unquote(path)

return path.endswith('/') or path.endswith('\\')

def chmod(self, paths, mode):

raise NotImplementedError('chmod is not implemented for Powershell')

def chown(self, paths, user):

raise NotImplementedError('chown is not implemented for Powershell')

def set_user_facl(self, paths, user, mode):

raise NotImplementedError('set_user_facl is not implemented for Powershell')

def remove(self, path, recurse=False):

path = self._escape(self._unquote(path))

if recurse:

return self._encode_script('''Remove-Item "%s" -Force -Recurse;''' % path)

else:

return self._encode_script('''Remove-Item "%s" -Force;''' % path)

def mkdtemp(self, basefile=None, system=False, mode=None, tmpdir=None):

# Windows does not have an equivalent for the system temp files, so

# the param is ignored

basefile = self._escape(self._unquote(basefile))

basetmpdir = tmpdir if tmpdir else self.get_option('remote_tmp')

script = '''

$tmp_path = [System.Environment]::ExpandEnvironmentVariables('%s')

$tmp = New-Item -Type Directory -Path $tmp_path -Name '%s'

$tmp.FullName | Write-Host -Separator ''

''' % (basetmpdir, basefile)

return self._encode_script(script.strip())

def expand_user(self, user_home_path, username=''):

# PowerShell only supports "~" (not "~username"). Resolve-Path ~ does

# not seem to work remotely, though by default we are always starting

# in the user's home directory.

user_home_path = self._unquote(user_home_path)

if user_home_path == '~':

script = 'Write-Host (Get-Location).Path'

elif user_home_path.startswith('~\\'):

script = 'Write-Host ((Get-Location).Path + "%s")' % self._escape(user_home_path[1:])

else:

script = 'Write-Host "%s"' % self._escape(user_home_path)

return self._encode_script(script)

def exists(self, path):

path = self._escape(self._unquote(path))

script = '''

If (Test-Path "%s")

{

$res = 0;

}

Else

{

$res = 1;

}

Write-Host "$res";

Exit $res;

''' % path

return self._encode_script(script)

def checksum(self, path, *args, **kwargs):

path = self._escape(self._unquote(path))

script = '''

If (Test-Path -PathType Leaf "%(path)s")

{

$sp = new-object -TypeName System.Security.Cryptography.SHA1CryptoServiceProvider;

$fp = [System.IO.File]::Open("%(path)s", [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read);

[System.BitConverter]::ToString($sp.ComputeHash($fp)).Replace("-", "").ToLower();

$fp.Dispose();

}

ElseIf (Test-Path -PathType Container "%(path)s")

{

Write-Host "3";

}

Else

{

Write-Host "1";

}

''' % dict(path=path)

return self._encode_script(script)

def build_module_command(self, env_string, shebang, cmd, arg_path=None):

# pipelining bypass

if cmd == '':

return '-'

# non-pipelining

cmd_parts = shlex.split(cmd, posix=False)

cmd_parts = list(map(to_text, cmd_parts))

if shebang and shebang.lower() == '#!powershell':

if not self._unquote(cmd_parts[0]).lower().endswith('.ps1'):

cmd_parts[0] = '"%s.ps1"' % self._unquote(cmd_parts[0])

cmd_parts.insert(0, '&')

elif shebang and shebang.startswith('#!'):

cmd_parts.insert(0, shebang[2:])

elif not shebang:

# The module is assumed to be a binary

cmd_parts[0] = self._unquote(cmd_parts[0])

cmd_parts.append(arg_path)

script = '''

Try

{

}

Catch

{

$_obj = @{ failed = $true }

If ($_.Exception.GetType)

{

$_obj.Add('msg', $_.Exception.Message)

}

Else

{

$_obj.Add('msg', $_.ToString())

}

If ($_.InvocationInfo.PositionMessage)

{

$_obj.Add('exception', $_.InvocationInfo.PositionMessage)

}

ElseIf ($_.ScriptStackTrace)

{

$_obj.Add('exception', $_.ScriptStackTrace)

}

Try

{

$_obj.Add('error_record', ($_ | ConvertTo-Json | ConvertFrom-Json))

}

Catch

{

}

Echo $_obj | ConvertTo-Json -Compress -Depth 99

Exit 1

}

''' % (env_string, ' '.join(cmd_parts))

return self._encode_script(script, preserve_rc=False)

def wrap_for_exec(self, cmd):

return '& %s' % cmd

def _unquote(self, value):

'''Remove any matching quotes that wrap the given value.'''

value = to_text(value or '')

m = re.match(r'^\s*?\'(.*?)\'\s*?$', value)

if m:

return m.group(1)

m = re.match(r'^\s*?"(.*?)"\s*?$', value)

if m:

return m.group(1)

return value

def _escape(self, value, include_vars=False):

'''Return value escaped for use in PowerShell command.'''

# http://www.techotopia.com/index.php/Windows_PowerShell_1.0_String_Quoting_and_Escape_Sequences

# http://stackoverflow.com/questions/764360/a-list-of-string-replacements-in-python

subs = [('\n', '`n'), ('\r', '`r'), ('\t', '`t'), ('\a', '`a'),

('\b', '`b'), ('\f', '`f'), ('\v', '`v'), ('"', '`"'),

('\'', '`\''), ('`', '``'), ('\x00', '`0')]

if include_vars:

subs.append(('$', '`$'))

pattern = '|'.join('(%s)' % re.escape(p) for p, s in subs)

substs = [s for p, s in subs]

def replace(m):

return substs[m.lastindex - 1]

return re.sub(pattern, replace, value)

def _encode_script(self, script, as_list=False, strict_mode=True, preserve_rc=True):

'''Convert a PowerShell script to a single base64-encoded command.'''

script = to_text(script)

if script == u'-':

cmd_parts = _common_args + ['-']

else:

if strict_mode:

script = u'Set-StrictMode -Version Latest\r\n%s' % script

# try to propagate exit code if present- won't work with begin/process/end-style scripts (ala put_file)

# NB: the exit code returned may be incorrect in the case of a successful command followed by an invalid command

if preserve_rc:

script = u'%s\r\nIf (-not $?) { If (Get-Variable LASTEXITCODE -ErrorAction SilentlyContinue) { exit $LASTEXITCODE } Else { exit 1 } }\r\n'\

% script

script = '\n'.join([x.strip() for x in script.splitlines() if x.strip()])

encoded_script = to_text(base64.b64encode(script.encode('utf-16-le')), 'utf-8')

cmd_parts = _common_args + ['-EncodedCommand', encoded_script]

if as_list:

return cmd_parts

return ' '.join(cmd_parts)

Coverage for lib/ansible/plugins/shell/powershell.py : 24%

136 statements 43 run 93 missing 0 excluded 1 partial