Complete rewrite of Windows exec wrapper (#21510)
* supports pipelining for faster execution * supports become (runas), creates interactive subsession under WinRM batch logon * supports usage of arbitrary module_utils files * modular exec wrapper payload supports easier extension * integrates async wrapper behavior for pipelined/become'd async * module_utils are loaded as true Powershell modules, no more runtime modifications to module code
This commit is contained in:
Matt Davis
GitHub
parent
7bf56ceee3
commit
8527013fbe
17 changed files with 1104 additions and 148 deletions
|
|
@ -265,7 +265,7 @@ DEFAULT_ASK_SUDO_PASS = get_config(p, DEFAULTS, 'ask_sudo_pass', 'ANSIBLE
|
|||
# Become
|
||||
BECOME_ERROR_STRINGS = {'sudo': 'Sorry, try again.', 'su': 'Authentication failure', 'pbrun': '', 'pfexec': '', 'doas': 'Permission denied', 'dzdo': '', 'ksu': 'Password incorrect'} #FIXME: deal with i18n
|
||||
BECOME_MISSING_STRINGS = {'sudo': 'sorry, a password is required to run sudo', 'su': '', 'pbrun': '', 'pfexec': '', 'doas': 'Authorization required', 'dzdo': '', 'ksu': 'No password given'} #FIXME: deal with i18n
|
||||
BECOME_METHODS = ['sudo','su','pbrun','pfexec','doas','dzdo','ksu']
|
||||
BECOME_METHODS = ['sudo','su','pbrun','pfexec','doas','dzdo','ksu','runas']
|
||||
BECOME_ALLOW_SAME_USER = get_config(p, 'privilege_escalation', 'become_allow_same_user', 'ANSIBLE_BECOME_ALLOW_SAME_USER', False, value_type='boolean')
|
||||
DEFAULT_BECOME_METHOD = get_config(p, 'privilege_escalation', 'become_method', 'ANSIBLE_BECOME_METHOD','sudo' if DEFAULT_SUDO else 'su' if DEFAULT_SU else 'sudo' ).lower()
|
||||
DEFAULT_BECOME = get_config(p, 'privilege_escalation', 'become', 'ANSIBLE_BECOME',False, value_type='boolean')
|
||||
|
|
|
|||
|
|
@ -28,6 +28,8 @@ import json
|
|||
import os
|
||||
import shlex
|
||||
import zipfile
|
||||
import random
|
||||
import re
|
||||
from io import BytesIO
|
||||
|
||||
from ansible.release import __version__, __author__
|
||||
|
|
@ -35,6 +37,7 @@ from ansible import constants as C
|
|||
from ansible.errors import AnsibleError
|
||||
from ansible.module_utils._text import to_bytes, to_text
|
||||
from ansible.plugins import module_utils_loader
|
||||
from ansible.plugins.shell.powershell import async_watchdog, async_wrapper, become_wrapper, leaf_exec
|
||||
# Must import strategy and use write_locks from there
|
||||
# If we import write_locks directly then we end up binding a
|
||||
# variable to the object and then it never gets updated.
|
||||
|
|
@ -603,7 +606,7 @@ def _find_module_utils(module_name, b_module_data, module_path, module_args, tas
|
|||
elif b'from ansible.module_utils.' in b_module_data:
|
||||
module_style = 'new'
|
||||
module_substyle = 'python'
|
||||
elif REPLACER_WINDOWS in b_module_data:
|
||||
elif REPLACER_WINDOWS in b_module_data or b'#Requires -Module' in b_module_data:
|
||||
module_style = 'new'
|
||||
module_substyle = 'powershell'
|
||||
elif REPLACER_JSONARGS in b_module_data:
|
||||
|
|
@ -733,33 +736,14 @@ def _find_module_utils(module_name, b_module_data, module_path, module_args, tas
|
|||
b_module_data = output.getvalue()
|
||||
|
||||
elif module_substyle == 'powershell':
|
||||
# Module replacer for jsonargs and windows
|
||||
lines = b_module_data.split(b'\n')
|
||||
for line in lines:
|
||||
if REPLACER_WINDOWS in line:
|
||||
# FIXME: Need to make a module_utils loader for powershell at some point
|
||||
ps_data = _slurp(os.path.join(_MODULE_UTILS_PATH, "powershell.ps1"))
|
||||
output.write(ps_data)
|
||||
py_module_names.add((b'powershell',))
|
||||
continue
|
||||
output.write(line + b'\n')
|
||||
b_module_data = output.getvalue()
|
||||
|
||||
module_args_json = to_bytes(json.dumps(module_args))
|
||||
b_module_data = b_module_data.replace(REPLACER_JSONARGS, module_args_json)
|
||||
|
||||
# Powershell/winrm don't actually make use of shebang so we can
|
||||
# safely set this here. If we let the fallback code handle this
|
||||
# it can fail in the presence of the UTF8 BOM commonly added by
|
||||
# Windows text editors
|
||||
shebang = u'#!powershell'
|
||||
|
||||
# Sanity check from 1.x days. This is currently useless as we only
|
||||
# get here if we are going to substitute powershell.ps1 into the
|
||||
# module anyway. Leaving it for when/if we add other powershell
|
||||
# module_utils files.
|
||||
if (b'powershell',) not in py_module_names:
|
||||
raise AnsibleError("missing required import in %s: # POWERSHELL_COMMON" % module_path)
|
||||
# powershell wrapper build is currently handled in build_windows_module_payload, called in action
|
||||
# _configure_module after this function returns.
|
||||
|
||||
elif module_substyle == 'jsonargs':
|
||||
module_args_json = to_bytes(json.dumps(module_args))
|
||||
|
|
@ -800,11 +784,8 @@ def modify_module(module_name, module_path, module_args, task_vars=dict(), modul
|
|||
... will result in the insertion of basic.py into the module
|
||||
from the module_utils/ directory in the source tree.
|
||||
|
||||
For powershell, there's equivalent conventions like this:
|
||||
|
||||
# POWERSHELL_COMMON
|
||||
|
||||
which results in the inclusion of the common code from powershell.ps1
|
||||
For powershell, this code effectively no-ops, as the exec wrapper requires access to a number of
|
||||
properties not available here.
|
||||
|
||||
"""
|
||||
with open(module_path, 'rb') as f:
|
||||
|
|
@ -839,3 +820,47 @@ def modify_module(module_name, module_path, module_args, task_vars=dict(), modul
|
|||
shebang = to_bytes(shebang, errors='surrogate_or_strict')
|
||||
|
||||
return (b_module_data, module_style, to_text(shebang, nonstring='passthru'))
|
||||
|
||||
def build_windows_module_payload(module_name, module_path, b_module_data, module_args, task_vars, task, play_context):
|
||||
exec_manifest = dict(
|
||||
module_entry=base64.b64encode(b_module_data),
|
||||
powershell_modules=dict(),
|
||||
module_args=module_args,
|
||||
actions=['exec']
|
||||
)
|
||||
|
||||
exec_manifest['exec'] = base64.b64encode(to_bytes(leaf_exec))
|
||||
|
||||
if task.async > 0:
|
||||
exec_manifest["actions"].insert(0, 'async_watchdog')
|
||||
exec_manifest["async_watchdog"] = base64.b64encode(to_bytes(async_watchdog))
|
||||
exec_manifest["actions"].insert(0, 'async_wrapper')
|
||||
exec_manifest["async_wrapper"] = base64.b64encode(to_bytes(async_wrapper))
|
||||
exec_manifest["async_jid"] = str(random.randint(0, 999999999999))
|
||||
exec_manifest["async_timeout_sec"] = task.async
|
||||
|
||||
if play_context.become and play_context.become_method=='runas':
|
||||
exec_manifest["actions"].insert(0, 'become')
|
||||
exec_manifest["become_user"] = play_context.become_user
|
||||
exec_manifest["become_password"] = play_context.become_pass
|
||||
exec_manifest["become"] = base64.b64encode(to_bytes(become_wrapper))
|
||||
|
||||
lines = b_module_data.split(b'\n')
|
||||
module_names = set()
|
||||
|
||||
requires_module_list = re.compile(r'(?i)^#requires \-module(?:s?) (.+)')
|
||||
|
||||
for line in lines:
|
||||
# legacy, equivalent to #Requires -Modules powershell
|
||||
if REPLACER_WINDOWS in line:
|
||||
module_names.add(b'powershell')
|
||||
# TODO: add #Requires checks for Ansible.ModuleUtils.X
|
||||
|
||||
for m in module_names:
|
||||
exec_manifest["powershell_modules"][m] = base64.b64encode(
|
||||
to_bytes(_slurp(os.path.join(_MODULE_UTILS_PATH, m + ".ps1"))))
|
||||
|
||||
# FUTURE: smuggle this back as a dict instead of serializing here; the connection plugin may need to modify it
|
||||
b_module_data = json.dumps(exec_manifest)
|
||||
|
||||
return b_module_data
|
||||
|
|
|
|||
|
|
@ -27,15 +27,7 @@
|
|||
#
|
||||
|
||||
Set-StrictMode -Version 2.0
|
||||
|
||||
# Ansible v2 will insert the module arguments below as a string containing
|
||||
# JSON; assign them to an environment variable and redefine $args so existing
|
||||
# modules will continue to work.
|
||||
$complex_args = @'
|
||||
<<INCLUDE_ANSIBLE_MODULE_JSON_ARGS>>
|
||||
'@
|
||||
Set-Content env:MODULE_COMPLEX_ARGS -Value $complex_args
|
||||
$args = @('env:MODULE_COMPLEX_ARGS')
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
# Helper function to set an "attribute" on a psobject instance in powershell.
|
||||
# This is a convenience to make adding Members to the object easier and
|
||||
|
|
@ -161,7 +153,7 @@ Function Get-AnsibleParam($obj, $name, $default = $null, $resultobj = @{}, $fail
|
|||
|
||||
# Iterate over aliases to find acceptable Member $name
|
||||
foreach ($alias in $aliases) {
|
||||
if (Get-Member -InputObject $obj -Name $alias) {
|
||||
if ($obj.ContainsKey($alias)) {
|
||||
$found = $alias
|
||||
break
|
||||
}
|
||||
|
|
@ -217,7 +209,6 @@ If (!(Get-Alias -Name "Get-attr" -ErrorAction SilentlyContinue))
|
|||
New-Alias -Name Get-attr -Value Get-AnsibleParam
|
||||
}
|
||||
|
||||
|
||||
# Helper filter/pipeline function to convert a value to boolean following current
|
||||
# Ansible practices
|
||||
# Example: $is_true = "true" | ConvertTo-Bool
|
||||
|
|
@ -251,6 +242,9 @@ Function Parse-Args($arguments, $supports_check_mode = $false)
|
|||
{
|
||||
$params = Get-Content $arguments[0] | ConvertFrom-Json
|
||||
}
|
||||
Else {
|
||||
$params = $complex_args
|
||||
}
|
||||
$check_mode = Get-AnsibleParam -obj $params -name "_ansible_check_mode" -type "bool" -default $false
|
||||
If ($check_mode -and -not $supports_check_mode)
|
||||
{
|
||||
|
|
@ -315,3 +309,6 @@ Function Get-PendingRebootStatus
|
|||
return $False
|
||||
}
|
||||
}
|
||||
|
||||
# this line must stay at the bottom to ensure all defined module parts are exported
|
||||
Export-ModuleMember -Alias * -Function * -Cmdlet *
|
||||
|
|
@ -550,10 +550,8 @@ class PlayContext(Base):
|
|||
becomecmd = '%s %s "%s"' % (exe, flags, success_cmd)
|
||||
|
||||
elif self.become_method == 'runas':
|
||||
raise AnsibleError("'runas' is not yet implemented")
|
||||
#FIXME: figure out prompt
|
||||
# this is not for use with winrm plugin but if they ever get ssh native on windoez
|
||||
becomecmd = '%s %s /user:%s "%s"' % (exe, flags, self.become_user, success_cmd)
|
||||
# become is handled inside the WinRM connection plugin
|
||||
becomecmd = cmd
|
||||
|
||||
elif self.become_method == 'doas':
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ from ansible import constants as C
|
|||
from ansible.compat.six import binary_type, string_types, text_type, iteritems, with_metaclass
|
||||
from ansible.compat.six.moves import shlex_quote
|
||||
from ansible.errors import AnsibleError, AnsibleConnectionFailure
|
||||
from ansible.executor.module_common import modify_module
|
||||
from ansible.executor.module_common import modify_module, build_windows_module_payload
|
||||
from ansible.module_utils._text import to_bytes, to_native, to_text
|
||||
from ansible.module_utils.json_utils import _filter_non_json_lines
|
||||
from ansible.parsing.utils.jsonify import jsonify
|
||||
|
|
@ -159,6 +159,14 @@ class ActionBase(with_metaclass(ABCMeta, object)):
|
|||
(module_data, module_style, module_shebang) = modify_module(module_name, module_path, module_args,
|
||||
task_vars=task_vars, module_compression=self._play_context.module_compression)
|
||||
|
||||
# FUTURE: we'll have to get fancier about this to support powershell over SSH on Windows...
|
||||
if self._connection.transport == "winrm":
|
||||
# WinRM always pipelines, so we need to build up a fancier module payload...
|
||||
module_data = build_windows_module_payload(module_name=module_name, module_path=module_path,
|
||||
b_module_data=module_data, module_args=module_args,
|
||||
task_vars=task_vars, task=self._task,
|
||||
play_context=self._play_context)
|
||||
|
||||
return (module_style, module_shebang, module_data, module_path)
|
||||
|
||||
def _compute_environment_string(self):
|
||||
|
|
@ -200,6 +208,9 @@ class ActionBase(with_metaclass(ABCMeta, object)):
|
|||
'''
|
||||
Determines if we are required and can do pipelining
|
||||
'''
|
||||
if self._connection.always_pipeline_modules:
|
||||
return True #eg, winrm
|
||||
|
||||
# any of these require a true
|
||||
for condition in [
|
||||
self._connection.has_pipelining,
|
||||
|
|
@ -610,6 +621,7 @@ class ActionBase(with_metaclass(ABCMeta, object)):
|
|||
|
||||
self._update_module_args(module_name, module_args, task_vars)
|
||||
|
||||
# FUTURE: refactor this along with module build process to better encapsulate "smart wrapper" functionality
|
||||
(module_style, shebang, module_data, module_path) = self._configure_module(module_name=module_name, module_args=module_args, task_vars=task_vars)
|
||||
display.vvv("Using module file %s" % module_path)
|
||||
if not shebang and module_style != 'binary':
|
||||
|
|
@ -834,10 +846,10 @@ class ActionBase(with_metaclass(ABCMeta, object)):
|
|||
'''
|
||||
|
||||
display.debug("_low_level_execute_command(): starting")
|
||||
if not cmd:
|
||||
# this can happen with powershell modules when there is no analog to a Windows command (like chmod)
|
||||
display.debug("_low_level_execute_command(): no command, exiting")
|
||||
return dict(stdout='', stderr='', rc=254)
|
||||
# if not cmd:
|
||||
# # this can happen with powershell modules when there is no analog to a Windows command (like chmod)
|
||||
# display.debug("_low_level_execute_command(): no command, exiting")
|
||||
# return dict(stdout='', stderr='', rc=254)
|
||||
|
||||
allow_same_user = C.BECOME_ALLOW_SAME_USER
|
||||
same_user = self._play_context.become_user == self._play_context.remote_user
|
||||
|
|
|
|||
|
|
@ -38,8 +38,11 @@ class ActionModule(ActionBase):
|
|||
# should not be set anymore but here for backwards compatibility
|
||||
del results['invocation']['module_args']
|
||||
|
||||
# FUTURE: better to let _execute_module calculate this internally?
|
||||
wrap_async = self._task.async and not self._connection.has_native_async
|
||||
|
||||
# do work!
|
||||
results = merge_hash(results, self._execute_module(tmp=tmp, task_vars=task_vars, wrap_async=self._task.async))
|
||||
results = merge_hash(results, self._execute_module(tmp=tmp, task_vars=task_vars, wrap_async=wrap_async))
|
||||
|
||||
# hack to keep --verbose from showing all the setup module results
|
||||
# moved from setup module as now we filter out all _ansible_ from results
|
||||
|
|
|
|||
|
|
@ -83,6 +83,7 @@ class ActionModule(ActionBase):
|
|||
# add preparation steps to one ssh roundtrip executing the script
|
||||
env_string = self._compute_environment_string()
|
||||
script_cmd = ' '.join([env_string, tmp_src, args])
|
||||
script_cmd = self._connection._shell.wrap_for_exec(script_cmd)
|
||||
|
||||
result.update(self._low_level_execute_command(cmd=script_cmd, sudoable=True))
|
||||
|
||||
|
|
|
|||
|
|
@ -61,6 +61,8 @@ class ConnectionBase(with_metaclass(ABCMeta, object)):
|
|||
'''
|
||||
|
||||
has_pipelining = False
|
||||
has_native_async = False # eg, winrm
|
||||
always_pipeline_modules = False # eg, winrm
|
||||
become_methods = C.BECOME_METHODS
|
||||
# When running over this connection type, prefer modules written in a certain language
|
||||
# as discovered by the specified file extension. An empty string as the
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ import traceback
|
|||
import json
|
||||
import tempfile
|
||||
import subprocess
|
||||
import itertools
|
||||
|
||||
HAVE_KERBEROS = False
|
||||
try:
|
||||
|
|
@ -41,6 +42,7 @@ from ansible.errors import AnsibleError, AnsibleConnectionFailure
|
|||
from ansible.errors import AnsibleFileNotFound
|
||||
from ansible.module_utils._text import to_bytes, to_native, to_text
|
||||
from ansible.plugins.connection import ConnectionBase
|
||||
from ansible.plugins.shell.powershell import exec_wrapper, become_wrapper, leaf_exec
|
||||
from ansible.utils.hashing import secure_hash
|
||||
from ansible.utils.path import makedirs_safe
|
||||
|
||||
|
|
@ -68,12 +70,14 @@ class Connection(ConnectionBase):
|
|||
|
||||
transport = 'winrm'
|
||||
module_implementation_preferences = ('.ps1', '.exe', '')
|
||||
become_methods = []
|
||||
become_methods = ['runas']
|
||||
allow_executable = False
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
|
||||
self.has_pipelining = False
|
||||
self.has_pipelining = True
|
||||
self.always_pipeline_modules = True
|
||||
self.has_native_async = True
|
||||
self.protocol = None
|
||||
self.shell_id = None
|
||||
self.delegate = None
|
||||
|
|
@ -92,6 +96,9 @@ class Connection(ConnectionBase):
|
|||
self._winrm_path = hostvars.get('ansible_winrm_path', '/wsman')
|
||||
self._winrm_user = self._play_context.remote_user
|
||||
self._winrm_pass = self._play_context.password
|
||||
self._become_method = self._play_context.become_method
|
||||
self._become_user = self._play_context.become_user
|
||||
self._become_pass = self._play_context.become_pass
|
||||
|
||||
self._kinit_cmd = hostvars.get('ansible_winrm_kinit_cmd', 'kinit')
|
||||
|
||||
|
|
@ -288,7 +295,51 @@ class Connection(ConnectionBase):
|
|||
self.shell_id = None
|
||||
self._connect()
|
||||
|
||||
def _create_raw_wrapper_payload(self, cmd):
|
||||
payload = {
|
||||
'module_entry': base64.b64encode(to_bytes(cmd)),
|
||||
'powershell_modules': {},
|
||||
'actions': ['exec'],
|
||||
'exec': base64.b64encode(to_bytes(leaf_exec))
|
||||
}
|
||||
|
||||
return json.dumps(payload)
|
||||
|
||||
def _wrapper_payload_stream(self, payload, buffer_size=200000):
|
||||
payload_bytes = to_bytes(payload)
|
||||
byte_count = len(payload_bytes)
|
||||
for i in range(0, byte_count, buffer_size):
|
||||
yield payload_bytes[i:i+buffer_size], i+buffer_size >= byte_count
|
||||
|
||||
def exec_command(self, cmd, in_data=None, sudoable=True):
|
||||
super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
|
||||
cmd_parts = self._shell._encode_script(exec_wrapper, as_list=True, strict_mode=False, preserve_rc=False)
|
||||
|
||||
# TODO: display something meaningful here
|
||||
display.vvv("EXEC (via pipeline wrapper)")
|
||||
|
||||
if not in_data:
|
||||
payload = self._create_raw_wrapper_payload(cmd)
|
||||
else:
|
||||
payload = in_data
|
||||
|
||||
result = self._winrm_exec(cmd_parts[0], cmd_parts[1:], from_exec=True, stdin_iterator=self._wrapper_payload_stream(payload))
|
||||
|
||||
result.std_out = to_bytes(result.std_out)
|
||||
result.std_err = to_bytes(result.std_err)
|
||||
|
||||
# parse just stderr from CLIXML output
|
||||
if self.is_clixml(result.std_err):
|
||||
try:
|
||||
result.std_err = self.parse_clixml_stream(result.std_err)
|
||||
except:
|
||||
# unsure if we're guaranteed a valid xml doc- use raw output in case of error
|
||||
pass
|
||||
|
||||
return (result.status_code, result.std_out, result.std_err)
|
||||
|
||||
|
||||
def exec_command_old(self, cmd, in_data=None, sudoable=True):
|
||||
super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
|
||||
cmd_parts = shlex.split(to_bytes(cmd), posix=False)
|
||||
cmd_parts = map(to_text, cmd_parts)
|
||||
|
|
|
|||
|
|
@ -172,3 +172,7 @@ class ShellBase(object):
|
|||
cmd += ' %s %s' % (self._SHELL_AND, cmd_to_append)
|
||||
|
||||
return cmd
|
||||
|
||||
def wrap_for_exec(self, cmd):
|
||||
"""wrap script execution with any necessary decoration (eg '&' for quoted powershell script paths)"""
|
||||
return cmd
|
||||
|
|
|
|||
|
|
@ -34,6 +34,845 @@ _powershell_version = os.environ.get('POWERSHELL_VERSION', None)
|
|||
if _powershell_version:
|
||||
_common_args = ['PowerShell', '-Version', _powershell_version] + _common_args[1:]
|
||||
|
||||
exec_wrapper = br'''
|
||||
#Requires -Version 3.0
|
||||
begin {
|
||||
$DebugPreference = "Continue"
|
||||
$ErrorActionPreference = "Stop"
|
||||
Set-StrictMode -Version 2
|
||||
|
||||
function ConvertTo-HashtableFromPsCustomObject ($myPsObject){
|
||||
$output = @{};
|
||||
$myPsObject | Get-Member -MemberType *Property | % {
|
||||
$val = $myPsObject.($_.name);
|
||||
If ($val -is [psobject]) {
|
||||
$val = ConvertTo-HashtableFromPsCustomObject $val
|
||||
}
|
||||
$output.($_.name) = $val
|
||||
}
|
||||
return $output;
|
||||
}
|
||||
# stream JSON including become_pw, ps_module_payload, bin_module_payload, become_payload, write_payload_path, preserve directives
|
||||
# exec runspace, capture output, cleanup, return module output
|
||||
|
||||
$json_raw = ""
|
||||
}
|
||||
process {
|
||||
$input_as_string = [string]$input
|
||||
|
||||
$json_raw += $input_as_string
|
||||
}
|
||||
end {
|
||||
If (-not $json_raw) {
|
||||
Write-Error "no input given" -Category InvalidArgument
|
||||
}
|
||||
$payload = ConvertTo-HashtableFromPsCustomObject (ConvertFrom-Json $json_raw)
|
||||
|
||||
# TODO: handle binary modules
|
||||
# TODO: handle persistence
|
||||
|
||||
$actions = $payload.actions
|
||||
|
||||
# pop 0th action as entrypoint
|
||||
$entrypoint = $payload.($actions[0])
|
||||
$payload.actions = $payload.actions[1..99]
|
||||
|
||||
$entrypoint = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($entrypoint))
|
||||
|
||||
# load the current action entrypoint as a module custom object with a Run method
|
||||
$entrypoint = New-Module -ScriptBlock ([scriptblock]::Create($entrypoint)) -AsCustomObject
|
||||
|
||||
Set-Variable -Scope global -Name complex_args -Value $payload["module_args"] | Out-Null
|
||||
|
||||
# dynamically create/load modules
|
||||
ForEach ($mod in $payload.powershell_modules.GetEnumerator()) {
|
||||
$decoded_module = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($mod.Value))
|
||||
New-Module -ScriptBlock ([scriptblock]::Create($decoded_module)) -Name $mod.Key | Import-Module | Out-Null
|
||||
}
|
||||
|
||||
$output = $entrypoint.Run($payload)
|
||||
|
||||
Write-Output $output
|
||||
}
|
||||
|
||||
''' # end exec_wrapper
|
||||
|
||||
leaf_exec = br'''
|
||||
Function Run($payload) {
|
||||
$entrypoint = $payload.module_entry
|
||||
|
||||
$entrypoint = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($entrypoint))
|
||||
|
||||
$ps = [powershell]::Create()
|
||||
|
||||
$ps.AddStatement().AddCommand("Set-Variable").AddParameters(@{Scope="global";Name="complex_args";Value=$payload.module_args}) | Out-Null
|
||||
$ps.AddCommand("Out-Null") | Out-Null
|
||||
|
||||
# redefine Write-Host to dump to output instead of failing- lots of scripts use it
|
||||
$ps.AddStatement().AddScript("Function Write-Host(`$msg){ Write-Output `$msg }") | Out-Null
|
||||
|
||||
# dynamically create/load modules
|
||||
ForEach ($mod in $payload.powershell_modules.GetEnumerator()) {
|
||||
$decoded_module = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($mod.Value))
|
||||
$ps.AddStatement().AddCommand("New-Module").AddParameters(@{ScriptBlock=([scriptblock]::Create($decoded_module));Name=$mod.Key}) | Out-Null
|
||||
$ps.AddCommand("Import-Module") | Out-Null
|
||||
$ps.AddCommand("Out-Null") | Out-Null
|
||||
}
|
||||
|
||||
$ps.AddStatement().AddScript($entrypoint) | Out-Null
|
||||
|
||||
$output = $ps.Invoke()
|
||||
|
||||
$output
|
||||
|
||||
# PS3 doesn't properly set HadErrors in many cases, inspect the error stream as a fallback
|
||||
If ($ps.HadErrors -or ($PSVersionTable.PSVersion.Major -lt 4 -and $ps.Streams.Error.Count -gt 0)) {
|
||||
[System.Console]::Error.WriteLine($($ps.Streams.Error | Out-String))
|
||||
$exit_code = $ps.Runspace.SessionStateProxy.GetVariable("LASTEXITCODE")
|
||||
If(-not $exit_code) {
|
||||
$exit_code = 1
|
||||
}
|
||||
$host.SetShouldExit($exit_code)
|
||||
}
|
||||
}
|
||||
''' # end leaf_exec
|
||||
|
||||
|
||||
become_wrapper = br'''
|
||||
Set-StrictMode -Version 2
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
$helper_def = @"
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Threading;
|
||||
using System.Security;
|
||||
using System.Security.AccessControl;
|
||||
using System.Security.Principal;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ansible.Shell
|
||||
{
|
||||
public class ProcessUtil
|
||||
{
|
||||
public static void GetProcessOutput(StreamReader stdoutStream, StreamReader stderrStream, out string stdout, out string stderr)
|
||||
{
|
||||
var sowait = new EventWaitHandle(false, EventResetMode.ManualReset);
|
||||
var sewait = new EventWaitHandle(false, EventResetMode.ManualReset);
|
||||
|
||||
string so = null, se = null;
|
||||
|
||||
ThreadPool.QueueUserWorkItem((s)=>
|
||||
{
|
||||
so = stdoutStream.ReadToEnd();
|
||||
sowait.Set();
|
||||
});
|
||||
|
||||
ThreadPool.QueueUserWorkItem((s) =>
|
||||
{
|
||||
se = stderrStream.ReadToEnd();
|
||||
sewait.Set();
|
||||
});
|
||||
|
||||
foreach(var wh in new WaitHandle[] { sowait, sewait })
|
||||
wh.WaitOne();
|
||||
|
||||
stdout = so;
|
||||
stderr = se;
|
||||
}
|
||||
|
||||
// http://stackoverflow.com/a/30687230/139652
|
||||
public static void GrantAccessToWindowStationAndDesktop(string username)
|
||||
{
|
||||
const int WindowStationAllAccess = 0x000f037f;
|
||||
GrantAccess(username, GetProcessWindowStation(), WindowStationAllAccess);
|
||||
const int DesktopRightsAllAccess = 0x000f01ff;
|
||||
GrantAccess(username, GetThreadDesktop(GetCurrentThreadId()), DesktopRightsAllAccess);
|
||||
}
|
||||
|
||||
private static void GrantAccess(string username, IntPtr handle, int accessMask)
|
||||
{
|
||||
SafeHandle safeHandle = new NoopSafeHandle(handle);
|
||||
GenericSecurity security =
|
||||
new GenericSecurity(false, ResourceType.WindowObject, safeHandle, AccessControlSections.Access);
|
||||
|
||||
security.AddAccessRule(
|
||||
new GenericAccessRule(new NTAccount(username), accessMask, AccessControlType.Allow));
|
||||
security.Persist(safeHandle, AccessControlSections.Access);
|
||||
}
|
||||
|
||||
[DllImport("user32.dll", SetLastError = true)]
|
||||
private static extern IntPtr GetProcessWindowStation();
|
||||
|
||||
[DllImport("user32.dll", SetLastError = true)]
|
||||
private static extern IntPtr GetThreadDesktop(int dwThreadId);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern int GetCurrentThreadId();
|
||||
|
||||
private class GenericAccessRule : AccessRule
|
||||
{
|
||||
public GenericAccessRule(IdentityReference identity, int accessMask, AccessControlType type) :
|
||||
base(identity, accessMask, false, InheritanceFlags.None, PropagationFlags.None, type) { }
|
||||
}
|
||||
|
||||
private class GenericSecurity : NativeObjectSecurity
|
||||
{
|
||||
public GenericSecurity(bool isContainer, ResourceType resType, SafeHandle objectHandle, AccessControlSections sectionsRequested)
|
||||
: base(isContainer, resType, objectHandle, sectionsRequested) { }
|
||||
|
||||
public new void Persist(SafeHandle handle, AccessControlSections includeSections) { base.Persist(handle, includeSections); }
|
||||
|
||||
public new void AddAccessRule(AccessRule rule) { base.AddAccessRule(rule); }
|
||||
|
||||
public override Type AccessRightType { get { throw new NotImplementedException(); } }
|
||||
|
||||
public override AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited,
|
||||
InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type) { throw new NotImplementedException(); }
|
||||
|
||||
public override Type AccessRuleType { get { return typeof(AccessRule); } }
|
||||
|
||||
public override AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited,
|
||||
InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags) { throw new NotImplementedException(); }
|
||||
|
||||
public override Type AuditRuleType { get { return typeof(AuditRule); } }
|
||||
}
|
||||
|
||||
private class NoopSafeHandle : SafeHandle
|
||||
{
|
||||
public NoopSafeHandle(IntPtr handle) : base(handle, false) { }
|
||||
public override bool IsInvalid { get { return false; } }
|
||||
protected override bool ReleaseHandle() { return true; }
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
"@
|
||||
|
||||
$exec_wrapper = {
|
||||
#Requires -Version 3.0
|
||||
$DebugPreference = "Continue"
|
||||
$ErrorActionPreference = "Stop"
|
||||
Set-StrictMode -Version 2
|
||||
|
||||
function ConvertTo-HashtableFromPsCustomObject ($myPsObject){
|
||||
$output = @{};
|
||||
$myPsObject | Get-Member -MemberType *Property | % {
|
||||
$val = $myPsObject.($_.name);
|
||||
If ($val -is [psobject]) {
|
||||
$val = ConvertTo-HashtableFromPsCustomObject $val
|
||||
}
|
||||
$output.($_.name) = $val
|
||||
}
|
||||
return $output;
|
||||
}
|
||||
# stream JSON including become_pw, ps_module_payload, bin_module_payload, become_payload, write_payload_path, preserve directives
|
||||
# exec runspace, capture output, cleanup, return module output
|
||||
|
||||
$json_raw = [System.Console]::In.ReadToEnd()
|
||||
|
||||
If (-not $json_raw) {
|
||||
Write-Error "no input given" -Category InvalidArgument
|
||||
}
|
||||
|
||||
$payload = ConvertTo-HashtableFromPsCustomObject (ConvertFrom-Json $json_raw)
|
||||
|
||||
# TODO: handle binary modules
|
||||
# TODO: handle persistence
|
||||
|
||||
$actions = $payload.actions
|
||||
|
||||
# pop 0th action as entrypoint
|
||||
$entrypoint = $payload.($actions[0])
|
||||
$payload.actions = $payload.actions[1..99]
|
||||
|
||||
|
||||
$entrypoint = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($entrypoint))
|
||||
|
||||
# load the current action entrypoint as a module custom object with a Run method
|
||||
$entrypoint = New-Module -ScriptBlock ([scriptblock]::Create($entrypoint)) -AsCustomObject
|
||||
|
||||
Set-Variable -Scope global -Name complex_args -Value $payload["module_args"] | Out-Null
|
||||
|
||||
# dynamically create/load modules
|
||||
ForEach ($mod in $payload.powershell_modules.GetEnumerator()) {
|
||||
$decoded_module = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($mod.Value))
|
||||
New-Module -ScriptBlock ([scriptblock]::Create($decoded_module)) -Name $mod.Key | Import-Module | Out-Null
|
||||
}
|
||||
|
||||
$output = $entrypoint.Run($payload)
|
||||
|
||||
Write-Output $output
|
||||
|
||||
} # end exec_wrapper
|
||||
|
||||
|
||||
Function Run($payload) {
|
||||
# NB: action popping handled inside subprocess wrapper
|
||||
|
||||
$username = $payload.become_user
|
||||
$password = $payload.become_password
|
||||
|
||||
Add-Type -TypeDefinition $helper_def
|
||||
|
||||
$exec_args = $null
|
||||
|
||||
$exec_application = "powershell"
|
||||
|
||||
# NB: CreateProcessWithLogonW commandline maxes out at 1024 chars, must bootstrap via filesystem
|
||||
$temp = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), [System.IO.Path]::GetRandomFileName() + ".ps1")
|
||||
$exec_wrapper.ToString() | Set-Content -Path $temp
|
||||
|
||||
# TODO: grant target user permissions on tempfile/tempdir
|
||||
|
||||
Try {
|
||||
|
||||
# Base64 encode the command so we don't have to worry about the various levels of escaping
|
||||
# $encoded_command = [Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes($exec_wrapper.ToString()))
|
||||
|
||||
# force the input encoding to preamble-free UTF8 before we create the new process
|
||||
[System.Console]::InputEncoding = $(New-Object System.Text.UTF8Encoding @($false))
|
||||
|
||||
$exec_args = @("-noninteractive", $temp)
|
||||
|
||||
$proc = New-Object System.Diagnostics.Process
|
||||
$psi = $proc.StartInfo
|
||||
$psi.FileName = $exec_application
|
||||
$psi.Arguments = $exec_args
|
||||
$psi.RedirectStandardInput = $true
|
||||
$psi.RedirectStandardOutput = $true
|
||||
$psi.RedirectStandardError = $true
|
||||
$psi.UseShellExecute = $false
|
||||
|
||||
If($username.Contains("\")) {
|
||||
$sp = $username.Split(@([char]"\"), 2)
|
||||
$domain = $sp[0]
|
||||
$username = $sp[1]
|
||||
}
|
||||
ElseIf ($username.Contains("@")) {
|
||||
$domain = $null
|
||||
}
|
||||
Else {
|
||||
$domain = "."
|
||||
}
|
||||
|
||||
$psi.Domain = $domain
|
||||
$psi.Username = $username
|
||||
$psi.Password = $($password | ConvertTo-SecureString -AsPlainText -Force)
|
||||
|
||||
[Ansible.Shell.ProcessUtil]::GrantAccessToWindowStationAndDesktop($username)
|
||||
|
||||
$proc.Start() | Out-Null # will always return $true for non shell-exec cases
|
||||
|
||||
$payload_string = $payload | ConvertTo-Json -Depth 99 -Compress
|
||||
|
||||
# push the execution payload over stdin
|
||||
$proc.StandardInput.WriteLine($payload_string)
|
||||
$proc.StandardInput.Close()
|
||||
|
||||
$stdout = $stderr = [string] $null
|
||||
|
||||
[Ansible.Shell.ProcessUtil]::GetProcessOutput($proc.StandardOutput, $proc.StandardError, [ref] $stdout, [ref] $stderr) | Out-Null
|
||||
|
||||
# TODO: decode CLIXML stderr output (and other streams?)
|
||||
|
||||
$proc.WaitForExit() | Out-Null
|
||||
|
||||
$rc = $proc.ExitCode
|
||||
|
||||
If ($rc -eq 0) {
|
||||
$stdout
|
||||
$stderr
|
||||
}
|
||||
Else {
|
||||
Throw "failed, rc was $rc, stderr was $stderr, stdout was $stdout"
|
||||
}
|
||||
}
|
||||
Finally {
|
||||
Remove-Item $temp -ErrorAction SilentlyContinue
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
''' # end become_wrapper
|
||||
|
||||
|
||||
async_wrapper = br'''
|
||||
Set-StrictMode -Version 2
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
# build exec_wrapper encoded command
|
||||
# start powershell with breakaway running exec_wrapper encodedcommand
|
||||
# stream payload to powershell with normal exec, but normal exec writes results to resultfile instead of stdout/stderr
|
||||
# return asyncresult to controller
|
||||
|
||||
$exec_wrapper = {
|
||||
#Requires -Version 3.0
|
||||
$DebugPreference = "Continue"
|
||||
$ErrorActionPreference = "Stop"
|
||||
Set-StrictMode -Version 2
|
||||
|
||||
function ConvertTo-HashtableFromPsCustomObject ($myPsObject){
|
||||
$output = @{};
|
||||
$myPsObject | Get-Member -MemberType *Property | % {
|
||||
$val = $myPsObject.($_.name);
|
||||
If ($val -is [psobject]) {
|
||||
$val = ConvertTo-HashtableFromPsCustomObject $val
|
||||
}
|
||||
$output.($_.name) = $val
|
||||
}
|
||||
return $output;
|
||||
}
|
||||
# stream JSON including become_pw, ps_module_payload, bin_module_payload, become_payload, write_payload_path, preserve directives
|
||||
# exec runspace, capture output, cleanup, return module output
|
||||
|
||||
$json_raw = [System.Console]::In.ReadToEnd()
|
||||
|
||||
If (-not $json_raw) {
|
||||
Write-Error "no input given" -Category InvalidArgument
|
||||
}
|
||||
|
||||
$payload = ConvertTo-HashtableFromPsCustomObject (ConvertFrom-Json $json_raw)
|
||||
|
||||
# TODO: handle binary modules
|
||||
# TODO: handle persistence
|
||||
|
||||
$actions = $payload.actions
|
||||
|
||||
# pop 0th action as entrypoint
|
||||
$entrypoint = $payload.($actions[0])
|
||||
$payload.actions = $payload.actions[1..99]
|
||||
|
||||
$entrypoint = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($entrypoint))
|
||||
|
||||
# load the current action entrypoint as a module custom object with a Run method
|
||||
$entrypoint = New-Module -ScriptBlock ([scriptblock]::Create($entrypoint)) -AsCustomObject
|
||||
|
||||
Set-Variable -Scope global -Name complex_args -Value $payload["module_args"] | Out-Null
|
||||
|
||||
# dynamically create/load modules
|
||||
ForEach ($mod in $payload.powershell_modules.GetEnumerator()) {
|
||||
$decoded_module = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($mod.Value))
|
||||
New-Module -ScriptBlock ([scriptblock]::Create($decoded_module)) -Name $mod.Key | Import-Module | Out-Null
|
||||
}
|
||||
|
||||
$output = $entrypoint.Run($payload)
|
||||
|
||||
Write-Output $output
|
||||
|
||||
} # end exec_wrapper
|
||||
|
||||
|
||||
Function Run($payload) {
|
||||
# BEGIN Ansible.Async native type definition
|
||||
$native_process_util = @"
|
||||
using Microsoft.Win32.SafeHandles;
|
||||
using System;
|
||||
using System.ComponentModel;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
|
||||
namespace Ansible.Async {
|
||||
|
||||
public static class NativeProcessUtil
|
||||
{
|
||||
[DllImport("kernel32.dll", SetLastError=true, CharSet=CharSet.Unicode, BestFitMapping=false)]
|
||||
public static extern bool CreateProcess(
|
||||
[MarshalAs(UnmanagedType.LPTStr)]
|
||||
string lpApplicationName,
|
||||
StringBuilder lpCommandLine,
|
||||
IntPtr lpProcessAttributes,
|
||||
IntPtr lpThreadAttributes,
|
||||
bool bInheritHandles,
|
||||
uint dwCreationFlags,
|
||||
IntPtr lpEnvironment,
|
||||
[MarshalAs(UnmanagedType.LPTStr)]
|
||||
string lpCurrentDirectory,
|
||||
STARTUPINFO lpStartupInfo,
|
||||
out PROCESS_INFORMATION lpProcessInformation);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError=true, CharSet=CharSet.Unicode)]
|
||||
public static extern uint SearchPath (
|
||||
string lpPath,
|
||||
string lpFileName,
|
||||
string lpExtension,
|
||||
int nBufferLength,
|
||||
[MarshalAs (UnmanagedType.LPTStr)]
|
||||
StringBuilder lpBuffer,
|
||||
out IntPtr lpFilePart);
|
||||
|
||||
[DllImport("kernel32.dll")]
|
||||
public static extern bool CreatePipe(out IntPtr hReadPipe, out IntPtr hWritePipe, SECURITY_ATTRIBUTES lpPipeAttributes, uint nSize);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError=true)]
|
||||
public static extern IntPtr GetStdHandle(StandardHandleValues nStdHandle);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError=true)]
|
||||
public static extern bool SetHandleInformation(IntPtr hObject, HandleFlags dwMask, int dwFlags);
|
||||
|
||||
|
||||
public static string SearchPath(string findThis)
|
||||
{
|
||||
StringBuilder sbOut = new StringBuilder(1024);
|
||||
IntPtr filePartOut;
|
||||
|
||||
if(SearchPath(null, findThis, null, sbOut.Capacity, sbOut, out filePartOut) == 0)
|
||||
throw new FileNotFoundException("Couldn't locate " + findThis + " on path");
|
||||
|
||||
return sbOut.ToString();
|
||||
}
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError=true)]
|
||||
static extern SafeFileHandle OpenThread(
|
||||
ThreadAccessRights dwDesiredAccess,
|
||||
bool bInheritHandle,
|
||||
int dwThreadId);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError=true)]
|
||||
static extern int ResumeThread(SafeHandle hThread);
|
||||
|
||||
public static void ResumeThreadById(int threadId)
|
||||
{
|
||||
var threadHandle = OpenThread(ThreadAccessRights.SUSPEND_RESUME, false, threadId);
|
||||
if(threadHandle.IsInvalid)
|
||||
throw new Exception(String.Format("Thread ID {0} is invalid ({1})", threadId,
|
||||
new Win32Exception(Marshal.GetLastWin32Error()).Message));
|
||||
|
||||
try
|
||||
{
|
||||
if(ResumeThread(threadHandle) == -1)
|
||||
throw new Exception(String.Format("Thread ID {0} cannot be resumed ({1})", threadId,
|
||||
new Win32Exception(Marshal.GetLastWin32Error()).Message));
|
||||
}
|
||||
finally
|
||||
{
|
||||
threadHandle.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
public static void ResumeProcessById(int pid)
|
||||
{
|
||||
var proc = Process.GetProcessById(pid);
|
||||
|
||||
// wait for at least one suspended thread in the process (this handles possible slow startup race where
|
||||
// primary thread of created-suspended process has not yet become runnable)
|
||||
var retryCount = 0;
|
||||
while(!proc.Threads.OfType<ProcessThread>().Any(t=>t.ThreadState == System.Diagnostics.ThreadState.Wait &&
|
||||
t.WaitReason == ThreadWaitReason.Suspended))
|
||||
{
|
||||
proc.Refresh();
|
||||
Thread.Sleep(50);
|
||||
if (retryCount > 100)
|
||||
throw new InvalidOperationException(String.Format("No threads were suspended in target PID {0} after 5s", pid));
|
||||
}
|
||||
|
||||
foreach(var thread in proc.Threads.OfType<ProcessThread>().Where(t => t.ThreadState == System.Diagnostics.ThreadState.Wait &&
|
||||
t.WaitReason == ThreadWaitReason.Suspended))
|
||||
ResumeThreadById(thread.Id);
|
||||
}
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
public class SECURITY_ATTRIBUTES
|
||||
{
|
||||
public int nLength;
|
||||
public IntPtr lpSecurityDescriptor;
|
||||
public bool bInheritHandle = false;
|
||||
|
||||
public SECURITY_ATTRIBUTES() {
|
||||
nLength = Marshal.SizeOf(this);
|
||||
}
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
public class STARTUPINFO
|
||||
{
|
||||
public Int32 cb;
|
||||
public IntPtr lpReserved;
|
||||
public IntPtr lpDesktop;
|
||||
public IntPtr lpTitle;
|
||||
public Int32 dwX;
|
||||
public Int32 dwY;
|
||||
public Int32 dwXSize;
|
||||
public Int32 dwYSize;
|
||||
public Int32 dwXCountChars;
|
||||
public Int32 dwYCountChars;
|
||||
public Int32 dwFillAttribute;
|
||||
public Int32 dwFlags;
|
||||
public Int16 wShowWindow;
|
||||
public Int16 cbReserved2;
|
||||
public IntPtr lpReserved2;
|
||||
public IntPtr hStdInput;
|
||||
public IntPtr hStdOutput;
|
||||
public IntPtr hStdError;
|
||||
|
||||
public STARTUPINFO() {
|
||||
cb = Marshal.SizeOf(this);
|
||||
}
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
public struct PROCESS_INFORMATION
|
||||
{
|
||||
public IntPtr hProcess;
|
||||
public IntPtr hThread;
|
||||
public int dwProcessId;
|
||||
public int dwThreadId;
|
||||
}
|
||||
|
||||
[Flags]
|
||||
enum ThreadAccessRights : uint
|
||||
{
|
||||
SUSPEND_RESUME = 0x0002
|
||||
}
|
||||
|
||||
[Flags]
|
||||
public enum StartupInfoFlags : uint
|
||||
{
|
||||
USESTDHANDLES = 0x00000100
|
||||
}
|
||||
|
||||
public enum StandardHandleValues : int
|
||||
{
|
||||
STD_INPUT_HANDLE = -10,
|
||||
STD_OUTPUT_HANDLE = -11,
|
||||
STD_ERROR_HANDLE = -12
|
||||
}
|
||||
|
||||
[Flags]
|
||||
public enum HandleFlags : uint
|
||||
{
|
||||
None = 0,
|
||||
INHERIT = 1
|
||||
}
|
||||
}
|
||||
"@ # END Ansible.Async native type definition
|
||||
|
||||
# calculate the result path so we can include it in the worker payload
|
||||
$jid = $payload.async_jid
|
||||
$local_jid = $jid + "." + $pid
|
||||
|
||||
$results_path = [System.IO.Path]::Combine($env:LOCALAPPDATA, ".ansible_async", $local_jid)
|
||||
|
||||
$payload.async_results_path = $results_path
|
||||
|
||||
[System.IO.Directory]::CreateDirectory([System.IO.Path]::GetDirectoryName($results_path)) | Out-Null
|
||||
|
||||
Add-Type -TypeDefinition $native_process_util
|
||||
|
||||
# FUTURE: create under new job to ensure all children die on exit?
|
||||
|
||||
# FUTURE: move these flags into C# enum
|
||||
# start process suspended + breakaway so we can record the watchdog pid without worrying about a completion race
|
||||
Set-Variable CREATE_BREAKAWAY_FROM_JOB -Value ([uint32]0x01000000) -Option Constant
|
||||
Set-Variable CREATE_SUSPENDED -Value ([uint32]0x00000004) -Option Constant
|
||||
Set-Variable CREATE_UNICODE_ENVIRONMENT -Value ([uint32]0x000000400) -Option Constant
|
||||
Set-Variable CREATE_NEW_CONSOLE -Value ([uint32]0x00000010) -Option Constant
|
||||
|
||||
$pstartup_flags = $CREATE_BREAKAWAY_FROM_JOB -bor $CREATE_UNICODE_ENVIRONMENT -bor $CREATE_NEW_CONSOLE -bor $CREATE_SUSPENDED
|
||||
|
||||
# execute the dynamic watchdog as a breakway process, which will in turn exec the module
|
||||
$si = New-Object Ansible.Async.STARTUPINFO
|
||||
|
||||
# setup stdin redirection, we'll leave stdout/stderr as normal
|
||||
$si.dwFlags = [Ansible.Async.StartupInfoFlags]::USESTDHANDLES
|
||||
$si.hStdOutput = [Ansible.Async.NativeProcessUtil]::GetStdHandle([Ansible.Async.StandardHandleValues]::STD_OUTPUT_HANDLE)
|
||||
$si.hStdError = [Ansible.Async.NativeProcessUtil]::GetStdHandle([Ansible.Async.StandardHandleValues]::STD_ERROR_HANDLE)
|
||||
|
||||
$stdin_read = $stdin_write = 0
|
||||
|
||||
$pipesec = New-Object Ansible.Async.SECURITY_ATTRIBUTES
|
||||
$pipesec.bInheritHandle = $true
|
||||
|
||||
If(-not [Ansible.Async.NativeProcessUtil]::CreatePipe([ref]$stdin_read, [ref]$stdin_write, $pipesec, 0)) {
|
||||
throw "Stdin pipe setup failed, Win32Error: $([System.Runtime.InteropServices.Marshal]::GetLastWin32Error())"
|
||||
}
|
||||
If(-not [Ansible.Async.NativeProcessUtil]::SetHandleInformation($stdin_write, [Ansible.Async.HandleFlags]::INHERIT, 0)) {
|
||||
throw "Stdin handle setup failed, Win32Error: $([System.Runtime.InteropServices.Marshal]::GetLastWin32Error())"
|
||||
}
|
||||
$si.hStdInput = $stdin_read
|
||||
|
||||
# need to use a preamble-free version of UTF8Encoding
|
||||
$utf8_encoding = New-Object System.Text.UTF8Encoding @($false)
|
||||
$stdin_fs = New-Object System.IO.FileStream @($stdin_write, [System.IO.FileAccess]::Write, $true, 32768)
|
||||
$stdin = New-Object System.IO.StreamWriter @($stdin_fs, $utf8_encoding, 32768)
|
||||
|
||||
$pi = New-Object Ansible.Async.PROCESS_INFORMATION
|
||||
|
||||
$encoded_command = [Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes($exec_wrapper.ToString()))
|
||||
|
||||
# FUTURE: direct cmdline CreateProcess path lookup fails- this works but is sub-optimal
|
||||
$exec_cmd = [Ansible.Async.NativeProcessUtil]::SearchPath("powershell.exe")
|
||||
$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
|
||||
|
||||
class ShellModule(object):
|
||||
|
||||
|
|
@ -51,6 +890,15 @@ class ShellModule(object):
|
|||
# env provider's limitations don't appear to be documented.
|
||||
safe_envkey = re.compile(r'^[\d\w_]{1,255}$')
|
||||
|
||||
# TODO: implement module transfer
|
||||
# TODO: implement #Requires -Modules parser/locator
|
||||
# TODO: add raw failure + errcode preservation (all success right now)
|
||||
# TODO: add KEEP_REMOTE_FILES support + debug wrapper dump
|
||||
# TODO: add become support
|
||||
# TODO: add binary module support
|
||||
# TODO: figure out non-pipelined path (or force pipelining)
|
||||
|
||||
|
||||
def assert_safe_env_key(self, key):
|
||||
if not self.safe_envkey.match(key):
|
||||
raise AnsibleError("Invalid PowerShell environment key: %s" % key)
|
||||
|
|
@ -164,6 +1012,12 @@ class ShellModule(object):
|
|||
return self._encode_script(script)
|
||||
|
||||
def build_module_command(self, env_string, shebang, cmd, arg_path=None, rm_tmp=None):
|
||||
# pipelining bypass
|
||||
if cmd == '':
|
||||
return ''
|
||||
|
||||
# non-pipelining
|
||||
|
||||
cmd_parts = shlex.split(to_bytes(cmd), posix=False)
|
||||
cmd_parts = map(to_text, cmd_parts)
|
||||
if shebang and shebang.lower() == '#!powershell':
|
||||
|
|
@ -218,6 +1072,9 @@ class ShellModule(object):
|
|||
script = '%s\nFinally { %s }' % (script, rm_cmd)
|
||||
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 '')
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
windows/ci/group2
|
||||
windows
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
- asyncresult.finished == 1
|
||||
- asyncresult.changed == true
|
||||
- asyncresult.ansible_async_watchdog_pid is number
|
||||
- asyncresult.module_tempdir is search('ansible-tmp-')
|
||||
# - asyncresult.module_tempdir is search('ansible-tmp-')
|
||||
- asyncresult.module_pid is number
|
||||
|
||||
# this part of the test is flaky- Windows PIDs are reused aggressively, so this occasionally fails due to a new process with the same ID
|
||||
|
|
@ -41,14 +41,14 @@
|
|||
# that:
|
||||
# - proclist.stdout.strip() == ''
|
||||
|
||||
- name: ensure that module_tempdir was deleted
|
||||
raw: Test-Path {{ asyncresult.module_tempdir }}
|
||||
register: tempdircheck
|
||||
|
||||
- name: validate tempdir response
|
||||
assert:
|
||||
that:
|
||||
- tempdircheck.stdout | search('False')
|
||||
#- name: ensure that module_tempdir was deleted
|
||||
# raw: Test-Path {{ asyncresult.module_tempdir }}
|
||||
# register: tempdircheck
|
||||
#
|
||||
#- name: validate tempdir response
|
||||
# assert:
|
||||
# that:
|
||||
# - tempdircheck.stdout | search('False')
|
||||
|
||||
- name: async poll retry
|
||||
async_test:
|
||||
|
|
@ -63,7 +63,7 @@
|
|||
- asyncresult.ansible_job_id is match('\d+\.\d+')
|
||||
- asyncresult.finished == 1
|
||||
- asyncresult.changed == true
|
||||
- asyncresult.module_tempdir is search('ansible-tmp-')
|
||||
# - asyncresult.module_tempdir is search('ansible-tmp-')
|
||||
- asyncresult.module_pid is number
|
||||
|
||||
# this part of the test is flaky- Windows PIDs are reused aggressively, so this occasionally fails due to a new process with the same ID
|
||||
|
|
@ -77,14 +77,14 @@
|
|||
# that:
|
||||
# - proclist.stdout.strip() == ''
|
||||
|
||||
- name: ensure that module_tempdir was deleted
|
||||
raw: Test-Path {{ asyncresult.module_tempdir }}
|
||||
register: tempdircheck
|
||||
|
||||
- name: validate tempdir response
|
||||
assert:
|
||||
that:
|
||||
- tempdircheck.stdout | search('False')
|
||||
#- name: ensure that module_tempdir was deleted
|
||||
# raw: Test-Path {{ asyncresult.module_tempdir }}
|
||||
# register: tempdircheck
|
||||
#
|
||||
#- name: validate tempdir response
|
||||
# assert:
|
||||
# that:
|
||||
# - tempdircheck.stdout | search('False')
|
||||
|
||||
- name: async poll timeout
|
||||
async_test:
|
||||
|
|
@ -135,7 +135,8 @@
|
|||
- asyncresult.finished == 1
|
||||
- asyncresult.changed == false
|
||||
- asyncresult | failed == true
|
||||
- asyncresult.msg is search('failing via exception')
|
||||
# TODO: reenable after catastrophic failure behavior is cleaned up
|
||||
# - asyncresult.msg is search('failing via exception')
|
||||
|
||||
|
||||
# FUTURE: figure out why the last iteration of this test often fails on shippable
|
||||
|
|
|
|||
|
|
@ -80,67 +80,69 @@
|
|||
- "not win_ping_extra_args_result|changed"
|
||||
- "win_ping_extra_args_result.ping == 'bloop'"
|
||||
|
||||
- name: test modified win_ping that throws an exception
|
||||
action: win_ping_throw
|
||||
register: win_ping_throw_result
|
||||
ignore_errors: true
|
||||
# TODO: fix code or tests? discrete error returns from PS are strange...
|
||||
|
||||
- name: check win_ping_throw result
|
||||
assert:
|
||||
that:
|
||||
- "win_ping_throw_result|failed"
|
||||
- "not win_ping_throw_result|changed"
|
||||
- "win_ping_throw_result.msg == 'ScriptHalted'"
|
||||
- "win_ping_throw_result.exception"
|
||||
- "win_ping_throw_result.error_record"
|
||||
|
||||
- name: test modified win_ping that throws a string exception
|
||||
action: win_ping_throw_string
|
||||
register: win_ping_throw_string_result
|
||||
ignore_errors: true
|
||||
|
||||
- name: check win_ping_throw_string result
|
||||
assert:
|
||||
that:
|
||||
- "win_ping_throw_string_result|failed"
|
||||
- "not win_ping_throw_string_result|changed"
|
||||
- "win_ping_throw_string_result.msg == 'no ping for you'"
|
||||
- "win_ping_throw_string_result.exception"
|
||||
- "win_ping_throw_string_result.error_record"
|
||||
|
||||
- name: test modified win_ping that has a syntax error
|
||||
action: win_ping_syntax_error
|
||||
register: win_ping_syntax_error_result
|
||||
ignore_errors: true
|
||||
|
||||
- name: check win_ping_syntax_error result
|
||||
assert:
|
||||
that:
|
||||
- "win_ping_syntax_error_result|failed"
|
||||
- "not win_ping_syntax_error_result|changed"
|
||||
- "win_ping_syntax_error_result.msg"
|
||||
- "win_ping_syntax_error_result.exception"
|
||||
|
||||
- name: test modified win_ping that has an error that only surfaces when strict mode is on
|
||||
action: win_ping_strict_mode_error
|
||||
register: win_ping_strict_mode_error_result
|
||||
ignore_errors: true
|
||||
|
||||
- name: check win_ping_strict_mode_error result
|
||||
assert:
|
||||
that:
|
||||
- "win_ping_strict_mode_error_result|failed"
|
||||
- "not win_ping_strict_mode_error_result|changed"
|
||||
- "win_ping_strict_mode_error_result.msg"
|
||||
- "win_ping_strict_mode_error_result.exception"
|
||||
|
||||
- name: test modified win_ping to verify a Set-Attr fix
|
||||
action: win_ping_set_attr data="fixed"
|
||||
register: win_ping_set_attr_result
|
||||
|
||||
- name: check win_ping_set_attr_result result
|
||||
assert:
|
||||
that:
|
||||
- "not win_ping_set_attr_result|failed"
|
||||
- "not win_ping_set_attr_result|changed"
|
||||
- "win_ping_set_attr_result.ping == 'fixed'"
|
||||
#- name: test modified win_ping that throws an exception
|
||||
# action: win_ping_throw
|
||||
# register: win_ping_throw_result
|
||||
# ignore_errors: true
|
||||
#
|
||||
#- name: check win_ping_throw result
|
||||
# assert:
|
||||
# that:
|
||||
# - "win_ping_throw_result|failed"
|
||||
# - "not win_ping_throw_result|changed"
|
||||
# - "win_ping_throw_result.msg == 'MODULE FAILURE'"
|
||||
# - "win_ping_throw_result.exception"
|
||||
# - "win_ping_throw_result.error_record"
|
||||
#
|
||||
#- name: test modified win_ping that throws a string exception
|
||||
# action: win_ping_throw_string
|
||||
# register: win_ping_throw_string_result
|
||||
# ignore_errors: true
|
||||
#
|
||||
#- name: check win_ping_throw_string result
|
||||
# assert:
|
||||
# that:
|
||||
# - "win_ping_throw_string_result|failed"
|
||||
# - "not win_ping_throw_string_result|changed"
|
||||
# - "win_ping_throw_string_result.msg == 'no ping for you'"
|
||||
# - "win_ping_throw_string_result.exception"
|
||||
# - "win_ping_throw_string_result.error_record"
|
||||
#
|
||||
#- name: test modified win_ping that has a syntax error
|
||||
# action: win_ping_syntax_error
|
||||
# register: win_ping_syntax_error_result
|
||||
# ignore_errors: true
|
||||
#
|
||||
#- name: check win_ping_syntax_error result
|
||||
# assert:
|
||||
# that:
|
||||
# - "win_ping_syntax_error_result|failed"
|
||||
# - "not win_ping_syntax_error_result|changed"
|
||||
# - "win_ping_syntax_error_result.msg"
|
||||
# - "win_ping_syntax_error_result.exception"
|
||||
#
|
||||
#- name: test modified win_ping that has an error that only surfaces when strict mode is on
|
||||
# action: win_ping_strict_mode_error
|
||||
# register: win_ping_strict_mode_error_result
|
||||
# ignore_errors: true
|
||||
#
|
||||
#- name: check win_ping_strict_mode_error result
|
||||
# assert:
|
||||
# that:
|
||||
# - "win_ping_strict_mode_error_result|failed"
|
||||
# - "not win_ping_strict_mode_error_result|changed"
|
||||
# - "win_ping_strict_mode_error_result.msg"
|
||||
# - "win_ping_strict_mode_error_result.exception"
|
||||
#
|
||||
#- name: test modified win_ping to verify a Set-Attr fix
|
||||
# action: win_ping_set_attr data="fixed"
|
||||
# register: win_ping_set_attr_result
|
||||
#
|
||||
#- name: check win_ping_set_attr_result result
|
||||
# assert:
|
||||
# that:
|
||||
# - "not win_ping_set_attr_result|failed"
|
||||
# - "not win_ping_set_attr_result|changed"
|
||||
# - "win_ping_set_attr_result.ping == 'fixed'"
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@
|
|||
that:
|
||||
- "ipconfig_invalid_result.rc != 0"
|
||||
- "ipconfig_invalid_result.stdout" # ipconfig displays errors on stdout.
|
||||
- "not ipconfig_invalid_result.stderr"
|
||||
# - "not ipconfig_invalid_result.stderr"
|
||||
- "ipconfig_invalid_result|failed"
|
||||
- "ipconfig_invalid_result|changed"
|
||||
|
||||
|
|
@ -93,14 +93,15 @@
|
|||
that:
|
||||
- "raw_result.stdout_lines[0] == 'wwe=raw'"
|
||||
|
||||
- name: run a raw command with unicode chars and quoted args (from https://github.com/ansible/ansible-modules-core/issues/1929)
|
||||
raw: Write-Host --% icacls D:\somedir\ /grant "! ЗАО. Руководство":F
|
||||
register: raw_result2
|
||||
|
||||
- name: make sure raw passes command as-is and doesn't split/rejoin args
|
||||
assert:
|
||||
that:
|
||||
- "raw_result2.stdout_lines[0] == '--% icacls D:\\\\somedir\\\\ /grant \"! ЗАО. Руководство\":F'"
|
||||
# TODO: this test doesn't work anymore since we had to internally map Write-Host to Write-Output
|
||||
#- name: run a raw command with unicode chars and quoted args (from https://github.com/ansible/ansible-modules-core/issues/1929)
|
||||
# raw: Write-Host --% icacls D:\somedir\ /grant "! ЗАО. Руководство":F
|
||||
# register: raw_result2
|
||||
#
|
||||
#- name: make sure raw passes command as-is and doesn't split/rejoin args
|
||||
# assert:
|
||||
# that:
|
||||
# - "raw_result2.stdout_lines[0] == '--% icacls D:\\\\somedir\\\\ /grant \"! ЗАО. Руководство\":F'"
|
||||
|
||||
# Assumes MaxShellsPerUser == 30 (the default)
|
||||
|
||||
|
|
|
|||
|
|
@ -2,5 +2,5 @@ Param(
|
|||
[bool]$boolvariable
|
||||
)
|
||||
|
||||
Write-Host $boolvariable.GetType()
|
||||
Write-Host $boolvariable
|
||||
Write-Output $boolvariable.GetType().FullName
|
||||
Write-Output $boolvariable
|
||||
|
|
|
|||
|
|
@ -23,11 +23,13 @@ if [ -s /tmp/windows.txt ]; then
|
|||
target="windows/ci/"
|
||||
|
||||
ansible-test windows-integration --color -v --retry-on-error "${target}" --requirements \
|
||||
--windows 2008-SP2 \
|
||||
--windows 2008-R2_SP1 \
|
||||
--windows 2012-RTM \
|
||||
--windows 2012-R2_RTM \
|
||||
|
||||
# removed due to increased memory usage from pipelining triggering memory quota bug in WMF3 (due to AMIs unpatched for KB2842230
|
||||
# --windows 2008-SP2 \
|
||||
# --windows 2008-R2_SP1 \
|
||||
|
||||
else
|
||||
echo "No changes requiring integration tests specific to Windows were detected."
|
||||
echo "Running Windows integration tests for a single version only."
|
||||
|
|
|
|||
Loading…
Reference in a new issue