|
|
#!/usr/bin/env python
|
|
|
"""
|
|
|
Tests the buffering behavior of stdio streams in `mercurial.utils.procutil`.
|
|
|
"""
|
|
|
from __future__ import absolute_import
|
|
|
|
|
|
import contextlib
|
|
|
import errno
|
|
|
import os
|
|
|
import signal
|
|
|
import subprocess
|
|
|
import sys
|
|
|
import tempfile
|
|
|
import unittest
|
|
|
|
|
|
from mercurial import pycompat, util
|
|
|
|
|
|
|
|
|
if pycompat.ispy3:
|
|
|
|
|
|
def set_noninheritable(fd):
|
|
|
# On Python 3, file descriptors are non-inheritable by default.
|
|
|
pass
|
|
|
|
|
|
|
|
|
else:
|
|
|
if pycompat.iswindows:
|
|
|
# unused
|
|
|
set_noninheritable = None
|
|
|
else:
|
|
|
import fcntl
|
|
|
|
|
|
def set_noninheritable(fd):
|
|
|
old = fcntl.fcntl(fd, fcntl.F_GETFD)
|
|
|
fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
|
|
|
|
|
|
|
|
|
TEST_BUFFERING_CHILD_SCRIPT = r'''
|
|
|
import os
|
|
|
|
|
|
from mercurial import dispatch
|
|
|
from mercurial.utils import procutil
|
|
|
|
|
|
dispatch.initstdio()
|
|
|
procutil.{stream}.write(b'aaa')
|
|
|
os.write(procutil.{stream}.fileno(), b'[written aaa]')
|
|
|
procutil.{stream}.write(b'bbb\n')
|
|
|
os.write(procutil.{stream}.fileno(), b'[written bbb\\n]')
|
|
|
'''
|
|
|
UNBUFFERED = b'aaa[written aaa]bbb\n[written bbb\\n]'
|
|
|
LINE_BUFFERED = b'[written aaa]aaabbb\n[written bbb\\n]'
|
|
|
FULLY_BUFFERED = b'[written aaa][written bbb\\n]aaabbb\n'
|
|
|
|
|
|
|
|
|
TEST_LARGE_WRITE_CHILD_SCRIPT = r'''
|
|
|
import os
|
|
|
import signal
|
|
|
import sys
|
|
|
|
|
|
from mercurial import dispatch
|
|
|
from mercurial.utils import procutil
|
|
|
|
|
|
signal.signal(signal.SIGINT, lambda *x: None)
|
|
|
dispatch.initstdio()
|
|
|
write_result = procutil.{stream}.write(b'x' * 1048576)
|
|
|
with os.fdopen(
|
|
|
os.open({write_result_fn!r}, os.O_WRONLY | getattr(os, 'O_TEMPORARY', 0)),
|
|
|
'w',
|
|
|
) as write_result_f:
|
|
|
write_result_f.write(str(write_result))
|
|
|
'''
|
|
|
|
|
|
|
|
|
TEST_BROKEN_PIPE_CHILD_SCRIPT = r'''
|
|
|
import os
|
|
|
import pickle
|
|
|
|
|
|
from mercurial import dispatch
|
|
|
from mercurial.utils import procutil
|
|
|
|
|
|
dispatch.initstdio()
|
|
|
procutil.stdin.read(1) # wait until parent process closed pipe
|
|
|
try:
|
|
|
procutil.{stream}.write(b'test')
|
|
|
procutil.{stream}.flush()
|
|
|
except EnvironmentError as e:
|
|
|
with os.fdopen(
|
|
|
os.open(
|
|
|
{err_fn!r},
|
|
|
os.O_WRONLY
|
|
|
| getattr(os, 'O_BINARY', 0)
|
|
|
| getattr(os, 'O_TEMPORARY', 0),
|
|
|
),
|
|
|
'wb',
|
|
|
) as err_f:
|
|
|
pickle.dump(e, err_f)
|
|
|
# Exit early to suppress further broken pipe errors at interpreter shutdown.
|
|
|
os._exit(0)
|
|
|
'''
|
|
|
|
|
|
|
|
|
@contextlib.contextmanager
|
|
|
def _closing(fds):
|
|
|
try:
|
|
|
yield
|
|
|
finally:
|
|
|
for fd in fds:
|
|
|
try:
|
|
|
os.close(fd)
|
|
|
except EnvironmentError:
|
|
|
pass
|
|
|
|
|
|
|
|
|
# In the following, we set the FDs non-inheritable mainly to make it possible
|
|
|
# for tests to close the receiving end of the pipe / PTYs.
|
|
|
|
|
|
|
|
|
@contextlib.contextmanager
|
|
|
def _devnull():
|
|
|
devnull = os.open(os.devnull, os.O_WRONLY)
|
|
|
# We don't have a receiving end, so it's not worth the effort on Python 2
|
|
|
# on Windows to make the FD non-inheritable.
|
|
|
with _closing([devnull]):
|
|
|
yield (None, devnull)
|
|
|
|
|
|
|
|
|
@contextlib.contextmanager
|
|
|
def _pipes():
|
|
|
rwpair = os.pipe()
|
|
|
# Pipes are already non-inheritable on Windows.
|
|
|
if not pycompat.iswindows:
|
|
|
set_noninheritable(rwpair[0])
|
|
|
set_noninheritable(rwpair[1])
|
|
|
with _closing(rwpair):
|
|
|
yield rwpair
|
|
|
|
|
|
|
|
|
@contextlib.contextmanager
|
|
|
def _ptys():
|
|
|
if pycompat.iswindows:
|
|
|
raise unittest.SkipTest("PTYs are not supported on Windows")
|
|
|
import pty
|
|
|
import tty
|
|
|
|
|
|
rwpair = pty.openpty()
|
|
|
set_noninheritable(rwpair[0])
|
|
|
set_noninheritable(rwpair[1])
|
|
|
with _closing(rwpair):
|
|
|
tty.setraw(rwpair[0])
|
|
|
yield rwpair
|
|
|
|
|
|
|
|
|
def _readall(fd, buffer_size, initial_buf=None):
|
|
|
buf = initial_buf or []
|
|
|
while True:
|
|
|
try:
|
|
|
s = os.read(fd, buffer_size)
|
|
|
except OSError as e:
|
|
|
if e.errno == errno.EIO:
|
|
|
# If the child-facing PTY got closed, reading from the
|
|
|
# parent-facing PTY raises EIO.
|
|
|
break
|
|
|
raise
|
|
|
if not s:
|
|
|
break
|
|
|
buf.append(s)
|
|
|
return b''.join(buf)
|
|
|
|
|
|
|
|
|
class TestStdio(unittest.TestCase):
|
|
|
def _test(
|
|
|
self,
|
|
|
child_script,
|
|
|
stream,
|
|
|
rwpair_generator,
|
|
|
check_output,
|
|
|
python_args=[],
|
|
|
post_child_check=None,
|
|
|
stdin_generator=None,
|
|
|
):
|
|
|
assert stream in ('stdout', 'stderr')
|
|
|
if stdin_generator is None:
|
|
|
stdin_generator = open(os.devnull, 'rb')
|
|
|
with rwpair_generator() as (
|
|
|
stream_receiver,
|
|
|
child_stream,
|
|
|
), stdin_generator as child_stdin:
|
|
|
proc = subprocess.Popen(
|
|
|
[sys.executable] + python_args + ['-c', child_script],
|
|
|
stdin=child_stdin,
|
|
|
stdout=child_stream if stream == 'stdout' else None,
|
|
|
stderr=child_stream if stream == 'stderr' else None,
|
|
|
)
|
|
|
try:
|
|
|
os.close(child_stream)
|
|
|
if stream_receiver is not None:
|
|
|
check_output(stream_receiver, proc)
|
|
|
except: # re-raises
|
|
|
proc.terminate()
|
|
|
raise
|
|
|
finally:
|
|
|
retcode = proc.wait()
|
|
|
self.assertEqual(retcode, 0)
|
|
|
if post_child_check is not None:
|
|
|
post_child_check()
|
|
|
|
|
|
def _test_buffering(
|
|
|
self, stream, rwpair_generator, expected_output, python_args=[]
|
|
|
):
|
|
|
def check_output(stream_receiver, proc):
|
|
|
self.assertEqual(_readall(stream_receiver, 1024), expected_output)
|
|
|
|
|
|
self._test(
|
|
|
TEST_BUFFERING_CHILD_SCRIPT.format(stream=stream),
|
|
|
stream,
|
|
|
rwpair_generator,
|
|
|
check_output,
|
|
|
python_args,
|
|
|
)
|
|
|
|
|
|
def test_buffering_stdout_devnull(self):
|
|
|
self._test_buffering('stdout', _devnull, None)
|
|
|
|
|
|
def test_buffering_stdout_pipes(self):
|
|
|
self._test_buffering('stdout', _pipes, FULLY_BUFFERED)
|
|
|
|
|
|
def test_buffering_stdout_ptys(self):
|
|
|
self._test_buffering('stdout', _ptys, LINE_BUFFERED)
|
|
|
|
|
|
def test_buffering_stdout_devnull_unbuffered(self):
|
|
|
self._test_buffering('stdout', _devnull, None, python_args=['-u'])
|
|
|
|
|
|
def test_buffering_stdout_pipes_unbuffered(self):
|
|
|
self._test_buffering('stdout', _pipes, UNBUFFERED, python_args=['-u'])
|
|
|
|
|
|
def test_buffering_stdout_ptys_unbuffered(self):
|
|
|
self._test_buffering('stdout', _ptys, UNBUFFERED, python_args=['-u'])
|
|
|
|
|
|
if not pycompat.ispy3 and not pycompat.iswindows:
|
|
|
# On Python 2 on non-Windows, we manually open stdout in line-buffered
|
|
|
# mode if connected to a TTY. We should check if Python was configured
|
|
|
# to use unbuffered stdout, but it's hard to do that.
|
|
|
test_buffering_stdout_ptys_unbuffered = unittest.expectedFailure(
|
|
|
test_buffering_stdout_ptys_unbuffered
|
|
|
)
|
|
|
|
|
|
def _test_large_write(self, stream, rwpair_generator, python_args=[]):
|
|
|
if not pycompat.ispy3 and pycompat.isdarwin:
|
|
|
# Python 2 doesn't always retry on EINTR, but the libc might retry.
|
|
|
# So far, it was observed only on macOS that EINTR is raised at the
|
|
|
# Python level. As Python 2 support will be dropped soon-ish, we
|
|
|
# won't attempt to fix it.
|
|
|
raise unittest.SkipTest("raises EINTR on macOS")
|
|
|
|
|
|
def check_output(stream_receiver, proc):
|
|
|
if not pycompat.iswindows:
|
|
|
# On Unix, we can provoke a partial write() by interrupting it
|
|
|
# by a signal handler as soon as a bit of data was written.
|
|
|
# We test that write() is called until all data is written.
|
|
|
buf = [os.read(stream_receiver, 1)]
|
|
|
proc.send_signal(signal.SIGINT)
|
|
|
else:
|
|
|
# On Windows, there doesn't seem to be a way to cause partial
|
|
|
# writes.
|
|
|
buf = []
|
|
|
self.assertEqual(
|
|
|
_readall(stream_receiver, 131072, buf), b'x' * 1048576
|
|
|
)
|
|
|
|
|
|
def post_child_check():
|
|
|
write_result_str = write_result_f.read()
|
|
|
if pycompat.ispy3:
|
|
|
# On Python 3, we test that the correct number of bytes is
|
|
|
# claimed to have been written.
|
|
|
expected_write_result_str = '1048576'
|
|
|
else:
|
|
|
# On Python 2, we only check that the large write does not
|
|
|
# crash.
|
|
|
expected_write_result_str = 'None'
|
|
|
self.assertEqual(write_result_str, expected_write_result_str)
|
|
|
|
|
|
with tempfile.NamedTemporaryFile('r') as write_result_f:
|
|
|
self._test(
|
|
|
TEST_LARGE_WRITE_CHILD_SCRIPT.format(
|
|
|
stream=stream, write_result_fn=write_result_f.name
|
|
|
),
|
|
|
stream,
|
|
|
rwpair_generator,
|
|
|
check_output,
|
|
|
python_args,
|
|
|
post_child_check=post_child_check,
|
|
|
)
|
|
|
|
|
|
def test_large_write_stdout_devnull(self):
|
|
|
self._test_large_write('stdout', _devnull)
|
|
|
|
|
|
def test_large_write_stdout_pipes(self):
|
|
|
self._test_large_write('stdout', _pipes)
|
|
|
|
|
|
def test_large_write_stdout_ptys(self):
|
|
|
self._test_large_write('stdout', _ptys)
|
|
|
|
|
|
def test_large_write_stdout_devnull_unbuffered(self):
|
|
|
self._test_large_write('stdout', _devnull, python_args=['-u'])
|
|
|
|
|
|
def test_large_write_stdout_pipes_unbuffered(self):
|
|
|
self._test_large_write('stdout', _pipes, python_args=['-u'])
|
|
|
|
|
|
def test_large_write_stdout_ptys_unbuffered(self):
|
|
|
self._test_large_write('stdout', _ptys, python_args=['-u'])
|
|
|
|
|
|
def test_large_write_stderr_devnull(self):
|
|
|
self._test_large_write('stderr', _devnull)
|
|
|
|
|
|
def test_large_write_stderr_pipes(self):
|
|
|
self._test_large_write('stderr', _pipes)
|
|
|
|
|
|
def test_large_write_stderr_ptys(self):
|
|
|
self._test_large_write('stderr', _ptys)
|
|
|
|
|
|
def test_large_write_stderr_devnull_unbuffered(self):
|
|
|
self._test_large_write('stderr', _devnull, python_args=['-u'])
|
|
|
|
|
|
def test_large_write_stderr_pipes_unbuffered(self):
|
|
|
self._test_large_write('stderr', _pipes, python_args=['-u'])
|
|
|
|
|
|
def test_large_write_stderr_ptys_unbuffered(self):
|
|
|
self._test_large_write('stderr', _ptys, python_args=['-u'])
|
|
|
|
|
|
def _test_broken_pipe(self, stream):
|
|
|
assert stream in ('stdout', 'stderr')
|
|
|
|
|
|
def check_output(stream_receiver, proc):
|
|
|
os.close(stream_receiver)
|
|
|
proc.stdin.write(b'x')
|
|
|
proc.stdin.close()
|
|
|
|
|
|
def post_child_check():
|
|
|
err = util.pickle.load(err_f)
|
|
|
self.assertEqual(err.errno, errno.EPIPE)
|
|
|
self.assertEqual(err.strerror, "Broken pipe")
|
|
|
|
|
|
with tempfile.NamedTemporaryFile('rb') as err_f:
|
|
|
self._test(
|
|
|
TEST_BROKEN_PIPE_CHILD_SCRIPT.format(
|
|
|
stream=stream, err_fn=err_f.name
|
|
|
),
|
|
|
stream,
|
|
|
_pipes,
|
|
|
check_output,
|
|
|
post_child_check=post_child_check,
|
|
|
stdin_generator=util.nullcontextmanager(subprocess.PIPE),
|
|
|
)
|
|
|
|
|
|
def test_broken_pipe_stdout(self):
|
|
|
self._test_broken_pipe('stdout')
|
|
|
|
|
|
def test_broken_pipe_stderr(self):
|
|
|
self._test_broken_pipe('stderr')
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
import silenttestrunner
|
|
|
|
|
|
silenttestrunner.main(__name__)
|
|
|
|
