Harden private desktop process ownership and cleanup

This commit is contained in:
阿白叔 committed 2026-10-15 10:51:51 +08:00
1 parent 2a4e793d70
commit 5c0f6a3fd3
2 files changed
+584 -24

No files matched your search

@@ -7,10 +7,14 @@ desktop, starts a process on that desktop, and closes resources it owns.
from __future__ import annotations
from dataclasses import dataclass
from contextlib import ExitStack
import ctypes
from ctypes import wintypes
import math
import os
from pathlib import Path
import subprocess
import time
from typing import Mapping, Sequence
from .errors import TaskCenterError
@@ -30,52 +34,319 @@ def build_startup_info(desktop_name: str) -> StartupInfo:
class _Win32Api:
def __init__(self) -> None:
try:
import win32con, win32job, win32process, win32service
import win32api, win32con, win32event, win32job, win32process, win32service
except ImportError as error:
raise TaskCenterError("private_desktop", "pywin32 is required for private desktop supervision") from error
self.con, self.job, self.process, self.service = win32con, win32job, win32process, win32service
self.event = win32event
self.open_process = win32api.OpenProcess
self._pending_cleanup = []
def create_desktop(self, name: str):
return self.service.CreateDesktop(name, 0, self.con.GENERIC_ALL, None)
def create_process(self, command: Sequence[str], desktop: str, cwd: Path | None, env: Mapping[str, str] | None):
def create_process(self, command: Sequence[str], desktop: str, cwd: Path | None, env: Mapping[str, str] | None,
*, stdout=None, stderr=None):
startup = self.process.STARTUPINFO()
startup.lpDesktop = desktop
flags = getattr(self.con, "CREATE_NO_WINDOW", 0)
handle, thread, pid, _ = self.process.CreateProcess(
str(command[0]), subprocess.list2cmdline([str(item) for item in command]),
None, None, False, flags, env, str(cwd) if cwd else None, startup,
)
thread.Close()
flags = self.con.CREATE_NO_WINDOW | self.con.CREATE_SUSPENDED
job = self.job.CreateJobObject(None, "")
process = None
try:
info = self.job.QueryInformationJobObject(job, self.job.JobObjectExtendedLimitInformation)
info["BasicLimitInformation"]["LimitFlags"] |= self.job.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
self.job.SetInformationJobObject(job, self.job.JobObjectExtendedLimitInformation, info)
streams = (None, None)
if stdout is not None or stderr is not None:
(handle, thread, pid, _), streams = _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr)
else:
handle, thread, pid, _ = self.process.CreateProcess(
str(command[0]), subprocess.list2cmdline([str(item) for item in command]),
None, None, False, flags, env, str(cwd) if cwd else None, startup,
)
process = _Win32Process(self.process, self.job, self.event, handle, job, int(pid), command,
open_process=getattr(self, 'open_process', None))
process.stdout, process.stderr = streams
process.thread = thread
self.job.AssignProcessToJobObject(job, handle)
except Exception:
handle.Close(); job.Close()
process.job_assigned = True
self.process.ResumeThread(thread)
thread.Close()
process.thread = None
except Exception as error:
try:
if process is not None:
# Assignment can fail before the job owns this suspended process.
process.close()
else:
job.Close()
except Exception as cleanup_error:
pending = getattr(self, '_pending_cleanup', None)
if pending is None:
self._pending_cleanup = pending = []
pending.append(process if process is not None else job)
raise TaskCenterError('private_desktop', f'launch failed: {error}; cleanup failed: {cleanup_error}') from error
raise
return _Win32Process(self.process, self.job, handle, job, int(pid))
return process
def close_pending(self):
errors, remaining = [], []
for resource in getattr(self, '_pending_cleanup', []):
try:
resource.close() if isinstance(resource, _Win32Process) else resource.Close()
except Exception as error:
errors.append(error)
remaining.append(resource)
self._pending_cleanup = remaining
_raise_cleanup_errors(errors)
def _raise_cleanup_errors(errors):
if errors:
raise TaskCenterError('private_desktop_cleanup', '; '.join(str(error) for error in errors))
def _stop_and_wait(process):
errors = []
running = True
try:
running = process.poll() is None
except Exception as error:
errors.append(error)
if running:
try:
process.terminate()
except Exception as error:
errors.append(error)
try:
process.wait(timeout=5.0)
except Exception as error:
errors.append(error)
return errors
def _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr):
"""Use an explicit inheritance list; never inherit unrelated parent handles."""
import msvcrt
import pywintypes
class NativeStartup(ctypes.Structure):
_fields_ = [
('cb', wintypes.DWORD), ('lpReserved', wintypes.LPWSTR),
('lpDesktop', wintypes.LPWSTR), ('lpTitle', wintypes.LPWSTR),
('dwX', wintypes.DWORD), ('dwY', wintypes.DWORD),
('dwXSize', wintypes.DWORD), ('dwYSize', wintypes.DWORD),
('dwXCountChars', wintypes.DWORD), ('dwYCountChars', wintypes.DWORD),
('dwFillAttribute', wintypes.DWORD), ('dwFlags', wintypes.DWORD),
('wShowWindow', wintypes.WORD), ('cbReserved2', wintypes.WORD),
('lpReserved2', ctypes.POINTER(ctypes.c_byte)),
('hStdInput', wintypes.HANDLE), ('hStdOutput', wintypes.HANDLE), ('hStdError', wintypes.HANDLE),
]
class ExtendedStartup(ctypes.Structure):
_fields_ = [('StartupInfo', NativeStartup), ('lpAttributeList', ctypes.c_void_p)]
class ProcessInformation(ctypes.Structure):
_fields_ = [('hProcess', wintypes.HANDLE), ('hThread', wintypes.HANDLE),
('dwProcessId', wintypes.DWORD), ('dwThreadId', wintypes.DWORD)]
kernel = ctypes.WinDLL('kernel32', use_last_error=True)
initialize = kernel.InitializeProcThreadAttributeList
initialize.argtypes = [ctypes.c_void_p, wintypes.DWORD, wintypes.DWORD, ctypes.POINTER(ctypes.c_size_t)]
initialize.restype = wintypes.BOOL
update = kernel.UpdateProcThreadAttribute
update.argtypes = [ctypes.c_void_p, wintypes.DWORD, ctypes.c_size_t, ctypes.c_void_p,
ctypes.c_size_t, ctypes.c_void_p, ctypes.c_void_p]
update.restype = wintypes.BOOL
delete = kernel.DeleteProcThreadAttributeList
delete.argtypes = [ctypes.c_void_p]
delete.restype = None
create = kernel.CreateProcessW
create.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR, ctypes.c_void_p, ctypes.c_void_p,
wintypes.BOOL, wintypes.DWORD, ctypes.c_void_p, wintypes.LPCWSTR,
ctypes.POINTER(ExtendedStartup), ctypes.POINTER(ProcessInformation)]
create.restype = wintypes.BOOL
readers = [None, None]
try:
with ExitStack() as children:
def output_handle(target, channel):
if target == subprocess.PIPE:
read_fd, write_fd = os.pipe()
readers[channel] = os.fdopen(read_fd, 'rb')
writer = children.enter_context(os.fdopen(write_fd, 'wb'))
elif target is None or target == subprocess.DEVNULL:
writer = children.enter_context(open(os.devnull, 'wb'))
else:
writer = children.enter_context(os.fdopen(os.dup(target.fileno()), 'wb'))
handle = msvcrt.get_osfhandle(writer.fileno())
os.set_handle_inheritable(handle, True)
return handle
stdin_file = children.enter_context(open(os.devnull, 'rb'))
stdin_handle = msvcrt.get_osfhandle(stdin_file.fileno())
os.set_handle_inheritable(stdin_handle, True)
stdout_handle = output_handle(stdout, 0)
stderr_handle = stdout_handle if stderr == subprocess.STDOUT else output_handle(stderr, 1)
handles = list(dict.fromkeys((stdin_handle, stdout_handle, stderr_handle)))
inherited = (wintypes.HANDLE * len(handles))(*handles)
size = ctypes.c_size_t()
initialize(None, 1, 0, ctypes.byref(size))
attributes = ctypes.create_string_buffer(size.value)
if not initialize(attributes, 1, 0, ctypes.byref(size)):
raise ctypes.WinError(ctypes.get_last_error())
try:
if not update(attributes, 0, 0x20002, inherited, ctypes.sizeof(inherited), None, None):
raise ctypes.WinError(ctypes.get_last_error())
startup = ExtendedStartup()
startup.StartupInfo.cb = ctypes.sizeof(startup)
startup.StartupInfo.lpDesktop = desktop
startup.StartupInfo.dwFlags = 0x100 # STARTF_USESTDHANDLES
startup.StartupInfo.hStdInput = stdin_handle
startup.StartupInfo.hStdOutput = stdout_handle
startup.StartupInfo.hStdError = stderr_handle
startup.lpAttributeList = ctypes.addressof(attributes)
information = ProcessInformation()
environment = None if env is None else ctypes.create_unicode_buffer(
'\0'.join(f'{key}={value}' for key, value in sorted(env.items(), key=lambda item: item[0].upper())) + '\0\0')
command_line = ctypes.create_unicode_buffer(subprocess.list2cmdline([str(item) for item in command]))
if not create(str(command[0]), command_line, None, None, True,
flags | 0x80000 | 0x400, environment, str(cwd) if cwd else None,
ctypes.byref(startup), ctypes.byref(information)):
raise ctypes.WinError(ctypes.get_last_error())
result = (pywintypes.HANDLE(information.hProcess), pywintypes.HANDLE(information.hThread),
information.dwProcessId, information.dwThreadId)
finally:
delete(attributes)
return result, readers
except BaseException:
for reader in readers:
if reader is not None:
reader.close()
raise
class _Win32Process:
def __init__(self, process_api, job_api, handle, job, pid: int):
def __init__(self, process_api, job_api, event_api, handle, job, pid: int, args, *, open_process=None):
self._process_api, self._job_api = process_api, job_api
self._event_api = event_api
self._open_process = open_process
self._descendant_handles = []
self._descendant_pids = set()
self.handle, self.job, self.pid = handle, job, pid
self.args = args
self.thread = None
self.job_assigned = False
self.returncode = None
self.stdout = self.stderr = None
def poll(self):
code = self._process_api.GetExitCodeProcess(self.handle)
return None if code == 259 else code
if self.returncode is not None or self.handle is None:
return self.returncode
status = self._event_api.WaitForSingleObject(self.handle, 0)
if status == 258: # WAIT_TIMEOUT: 259 is also a valid *completed* exit code.
return None
if status != 0:
raise OSError(f'process wait failed with status {status}')
self.returncode = self._process_api.GetExitCodeProcess(self.handle)
return self.returncode
def wait(self, timeout=None):
if self.returncode is not None:
return self.returncode
if self.handle is None:
raise OSError('owned process handle is closed before exit was confirmed')
milliseconds = 0xFFFFFFFF if timeout is None else min(max(math.ceil(timeout * 1000), 0), 0xFFFFFFFE)
status = self._event_api.WaitForSingleObject(self.handle, milliseconds)
if status == 258:
raise subprocess.TimeoutExpired(self.args, timeout)
if status != 0:
raise OSError(f'process wait failed with status {status}')
self.returncode = self._process_api.GetExitCodeProcess(self.handle)
return self.returncode
def terminate(self):
if self.handle is None:
return
if not self.job_assigned:
self._process_api.TerminateProcess(self.handle, 1)
return
errors = []
try:
self._remember_descendants()
except Exception as error:
errors.append(error)
try:
self._job_api.TerminateJobObject(self.job, 1)
except Exception:
self._process_api.TerminateProcess(self.handle, 1)
_raise_cleanup_errors(errors)
kill = terminate
def _remember_descendants(self):
if self._open_process is None or self.job is None:
return
for pid in self._job_api.QueryInformationJobObject(self.job, self._job_api.JobObjectBasicProcessIdList):
if pid == self.pid or pid in self._descendant_pids:
continue
try:
self._descendant_handles.append(self._open_process(0x100000, False, pid))
self._descendant_pids.add(pid)
except OSError as error:
if getattr(error, 'winerror', error.args[0]) != 87:
raise
def close(self):
self.handle.Close(); self.job.Close()
errors = []
if self.handle is not None:
errors.extend(_stop_and_wait(self))
deadline = time.monotonic() + 5.0
if self.job is not None and self.job_assigned:
try:
# A completed root can leave grandchildren holding the desktop.
self._remember_descendants()
self._job_api.TerminateJobObject(self.job, 1)
while self._job_api.QueryInformationJobObject(
self.job, self._job_api.JobObjectBasicAccountingInformation,
)['ActiveProcesses']:
if time.monotonic() >= deadline:
raise TimeoutError('owned job descendants did not exit within 5 seconds')
time.sleep(0.01)
except Exception as error:
errors.append(error)
retained = []
for descendant in self._descendant_handles:
try:
# Job accounting can reach zero before a terminated process is signaled.
remaining = max(0, math.ceil((deadline - time.monotonic()) * 1000))
if self._event_api.WaitForSingleObject(descendant, remaining) != 0:
raise TimeoutError('owned job descendant exit was not confirmed within 5 seconds')
except Exception as error:
errors.append(error)
retained.append(descendant)
continue
try:
descendant.Close()
except Exception as error:
errors.append(error)
retained.append(descendant)
self._descendant_handles = retained
for name in ('job', 'thread', 'handle'):
handle = getattr(self, name)
if name == 'handle' and self.returncode is None:
# Keep the only termination/wait capability until cleanup can retry.
continue
if handle is not None:
try:
handle.Close()
setattr(self, name, None)
except Exception as error:
errors.append(error)
for stream in (self.stdout, self.stderr):
if stream is not None:
try:
stream.close()
except Exception as error:
errors.append(error)
_raise_cleanup_errors(errors)
class PrivateDesktop:
@@ -111,6 +382,8 @@ class PrivateDesktop:
*,
cwd: Path | None = None,
env: Mapping[str, str] | None = None,
stdout=None,
stderr=None,
) -> subprocess.Popen[str]:
if not self.enabled or self._handle is None:
raise TaskCenterError("private_desktop", "process launch requires an owned private desktop")
@@ -118,19 +391,36 @@ class PrivateDesktop:
raise TaskCenterError("private_desktop", "private desktop command is empty")
if self._api is None:
raise TaskCenterError("private_desktop", "private desktop process API is unavailable")
process = self._api.create_process(command, build_startup_info(self.name).lpDesktop, cwd, env)
options = {} if stdout is None and stderr is None else {'stdout': stdout, 'stderr': stderr}
process = self._api.create_process(command, build_startup_info(self.name).lpDesktop, cwd, env, **options)
self._processes.append(process)
return process
def close(self) -> None:
errors, remaining = [], []
for process in reversed(self._processes):
if process.poll() is None:
process.terminate()
close = getattr(process, "close", None)
if close:
close()
self._processes.clear()
process_errors = _stop_and_wait(process)
errors.extend(process_errors)
failed = bool(process_errors)
try:
process.close()
except Exception as error:
errors.append(error)
failed = True
if failed:
remaining.append(process)
self._processes = list(reversed(remaining))
close_pending = getattr(self._api, 'close_pending', None)
if close_pending:
try:
close_pending()
except Exception as error:
errors.append(error)
close_desktop = getattr(self._handle, "CloseDesktop", None)
if close_desktop:
close_desktop()
self._handle = None
try:
close_desktop()
self._handle = None
except Exception as error:
errors.append(error)
_raise_cleanup_errors(errors)
+270
View File
@@ -1,8 +1,14 @@
from pathlib import Path
import subprocess
import os
import sys
from uuid import uuid4
from types import SimpleNamespace
import pytest
from dx_productivity.trial_task_center.errors import TaskCenterError
from dx_productivity.trial_task_center.isolated_desktop import PrivateDesktop, build_startup_info
from dx_productivity.trial_task_center.isolated_desktop import _Win32Api, _Win32Process
def test_startup_info_always_targets_private_desktop():
@@ -16,3 +22,267 @@ def test_private_desktop_never_falls_back_to_input_desktop(monkeypatch):
monkeypatch.setattr(desktop, '_handle', None)
with pytest.raises(TaskCenterError, match='private desktop'):
desktop.start_process(('cad.exe',))
class Handle:
def __init__(self, name, events, fail_once=False):
self.name, self.events, self.fail_once = name, events, fail_once
self.closed = False
def Close(self):
self.events.append(('close', self.name))
if self.fail_once:
self.fail_once = False
raise OSError('close failed')
self.closed = True
def native_api(*, assign_error=False):
events = []
process_handle = Handle('process', events)
thread = Handle('thread', events)
job = Handle('job', events)
state = {'running': True, 'code': 259}
def create(*args):
events.append(('create', args[5]))
return process_handle, thread, 42, 43
def assign(*_args):
events.append(('assign',))
if assign_error:
raise OSError('assign failed')
def terminate(*_args):
events.append(('terminate',))
state['running'] = False
def wait(_handle, timeout):
events.append(('wait', timeout))
return 258 if state['running'] else 0
api = _Win32Api.__new__(_Win32Api)
api.con = SimpleNamespace(CREATE_NO_WINDOW=0x8000000, CREATE_SUSPENDED=4)
api.process = SimpleNamespace(
STARTUPINFO=lambda: SimpleNamespace(), CreateProcess=create,
ResumeThread=lambda _thread: events.append(('resume',)),
GetExitCodeProcess=lambda _handle: state['code'], TerminateProcess=terminate,
)
api.job = SimpleNamespace(
CreateJobObject=lambda *_args: job,
QueryInformationJobObject=lambda _job, kind: (
{'BasicLimitInformation': {'LimitFlags': 0}} if kind == 9 else {'ActiveProcesses': int(state['running'])}),
SetInformationJobObject=lambda *_args: events.append(('limits',)),
AssignProcessToJobObject=assign, TerminateJobObject=terminate,
JobObjectExtendedLimitInformation=9, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE=0x2000,
JobObjectBasicAccountingInformation=1,
)
api.event = SimpleNamespace(WaitForSingleObject=wait)
return api, events, state, process_handle, job
def test_process_is_suspended_until_job_assignment():
api, events, *_ = native_api()
process = api.create_process(('python.exe',), 'winsta0\\private', None, None)
assert process.pid == 42
assert ('create', 0x8000004) in events
assert events.index(('assign',)) < events.index(('resume',))
def test_failed_job_assignment_terminates_and_reaps_owned_process():
api, events, state, process_handle, job = native_api(assign_error=True)
with pytest.raises(Exception, match='assign failed'):
api.create_process(('python.exe',), 'winsta0\\private', None, None)
assert not state['running']
assert events.index(('wait', 0)) < events.index(('close', 'process'))
assert process_handle.closed and job.closed
assert ('resume',) not in events
def test_wait_uses_signal_and_accepts_real_exit_code_259():
api, events, state, *_ = native_api()
process = api.create_process(('python.exe',), 'winsta0\\private', None, None)
with pytest.raises(subprocess.TimeoutExpired):
process.wait(timeout=0.025)
assert ('wait', 25) in events
assert process.poll() is None
state['running'] = False
assert process.poll() == 259
assert process.wait(timeout=0) == 259
def test_process_close_attempts_all_handles_and_retries_failed_handle():
api, events, state, process_handle, job = native_api()
process = api.create_process(('python.exe',), 'winsta0\\private', None, None)
process_handle.fail_once = True
with pytest.raises(TaskCenterError, match='close failed'):
process.close()
assert job.closed
assert not state['running']
process.close()
assert process_handle.closed
process.close()
assert events.count(('close', 'job')) == 1
def test_desktop_cleanup_continues_after_process_error_and_retries():
events = []
class OwnedProcess:
def __init__(self, failing=False):
self.failing = failing
def poll(self):
return None
def terminate(self):
events.append('terminate')
def wait(self, timeout):
events.append(('wait', timeout))
def close(self):
events.append('process-close')
if self.failing:
self.failing = False
raise OSError('process close failed')
class DesktopHandle:
def CloseDesktop(self):
events.append('desktop-close')
desktop = PrivateDesktop('private', enabled=True)
desktop._handle = DesktopHandle()
desktop._processes = [OwnedProcess(), OwnedProcess(failing=True)]
with pytest.raises(TaskCenterError, match='process close failed'):
desktop.close()
assert events.count('process-close') == 2
assert events[-1] == 'desktop-close'
assert ('wait', 5.0) in events
desktop.close()
assert events.count('process-close') == 3
def test_desktop_close_reports_bounded_process_timeout_and_closes_handles():
events = []
process = SimpleNamespace(
poll=lambda: None, terminate=lambda: events.append('terminate'),
wait=lambda timeout: (_ for _ in ()).throw(subprocess.TimeoutExpired('owned', timeout)),
close=lambda: events.append('process-close'),
)
desktop = PrivateDesktop('private', enabled=True)
desktop._handle = SimpleNamespace(CloseDesktop=lambda: events.append('desktop-close'))
desktop._processes = [process]
with pytest.raises(TaskCenterError, match='timed out'):
desktop.close()
assert events == ['terminate', 'process-close', 'desktop-close']
@pytest.mark.skipif(os.name != 'nt', reason='native Windows desktop/process boundary')
def test_native_private_process_has_captured_output_and_real_exit_259():
with PrivateDesktop('dx-test-' + uuid4().hex, enabled=True) as desktop:
process = desktop.start_process(
(sys.executable, '-c', "import sys,os; print('private-out',flush=True); print('private-err',file=sys.stderr,flush=True); os._exit(259)"),
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
)
assert process.stdout.readline() == b'private-out\r\n'
assert process.stderr.readline() == b'private-err\r\n'
assert process.wait(timeout=5) == 259
assert process.poll() == 259
def test_failed_rollback_termination_still_releases_owned_handles():
api, events, state, process_handle, job = native_api(assign_error=True)
api.process.TerminateProcess = lambda *_args: (_ for _ in ()).throw(OSError('terminate failed'))
with pytest.raises(Exception, match='assign failed'):
api.create_process(('python.exe',), 'winsta0\\private', None, None)
assert job.closed
assert ('close', 'thread') in events
# A process outside the job still needs its handle for a cleanup retry.
assert not process_handle.closed
def terminate(*_args):
state['running'] = False
api.process.TerminateProcess = terminate
api.close_pending()
assert process_handle.closed
def test_poll_failure_does_not_skip_termination_or_bounded_wait():
events = []
def failed_poll():
raise OSError('poll failed')
process = SimpleNamespace(
poll=failed_poll, terminate=lambda: events.append('terminate'),
wait=lambda timeout: events.append(('wait', timeout)),
close=lambda: events.append('close'),
)
desktop = PrivateDesktop('private', enabled=True)
desktop._processes = [process]
with pytest.raises(TaskCenterError, match='poll failed'):
desktop.close()
assert events == ['terminate', ('wait', 5.0), 'close']
def test_desktop_handle_close_failure_is_retried():
events = []
handle = Handle('desktop', events, fail_once=True)
handle.CloseDesktop = handle.Close
desktop = PrivateDesktop('private', enabled=True)
desktop._handle = handle
with pytest.raises(TaskCenterError, match='close failed'):
desktop.close()
assert desktop._handle is handle
desktop.close()
assert handle.closed and desktop._handle is None
def test_descendant_handles_are_owned_before_terminating_the_job():
api, events, _state, *_ = native_api()
api.job.JobObjectBasicProcessIdList = 3
query = api.job.QueryInformationJobObject
api.job.QueryInformationJobObject = lambda job, kind: [42, 43] if kind == 3 else query(job, kind)
def open_child(_access, _inherit, pid):
events.append(('open-child', pid))
return Handle('child', events)
api.open_process = open_child
process = api.create_process(('python.exe',), 'winsta0\\private', None, None)
desktop = PrivateDesktop('private', enabled=True)
desktop._processes = [process]
desktop.close()
assert events.index(('open-child', 43)) < events.index(('terminate',))
assert ('close', 'child') in events
def test_unconfirmed_descendant_exit_retains_handle_for_cleanup_retry():
api, events, state, *_ = native_api()
process = api.create_process(('python.exe',), 'winsta0\\private', None, None)
child = Handle('child', events)
process._descendant_handles = [child]
original_wait = api.event.WaitForSingleObject
pending = {'child': True}
api.event.WaitForSingleObject = lambda handle, timeout: (
258 if handle is child and pending['child'] else original_wait(handle, timeout))
with pytest.raises(TaskCenterError, match='descendant exit'):
process.close()
assert not child.closed
pending['child'] = False
process.close()
assert child.closed
@pytest.mark.skipif(os.name != 'nt', reason='native Windows job descendant cleanup')
@pytest.mark.parametrize('parent_exits', [True, False])
def test_native_private_job_kills_descendant_after_root_exit(parent_exits):
import win32api
import win32event
import win32service
import pywintypes
name = 'dx-test-' + uuid4().hex
child_handle = None
try:
with PrivateDesktop(name, enabled=True) as desktop:
process = desktop.start_process((
sys.executable, '-c',
"import subprocess,sys,time; p=subprocess.Popen([sys.executable,'-c','import time;time.sleep(60)']); print(p.pid,flush=True)"
+ ('' if parent_exits else '; time.sleep(60)'),
), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
child_pid = int(process.stdout.readline())
child_handle = win32api.OpenProcess(0x100000, False, child_pid)
if parent_exits:
assert process.wait(timeout=5) == 0
assert win32event.WaitForSingleObject(child_handle, 0) == 0
with pytest.raises(pywintypes.error):
unexpected = win32service.OpenDesktop(name, 0, False, 1)
unexpected.CloseDesktop()
finally:
if child_handle is not None:
child_handle.Close()