( )⚙ D12313 procutil: delete Python 2 support code

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12313

procutil: delete Python 2 support code
ClosedPublic

Authored by indygreg on Mar 2 2022, 6:31 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG3681b4c56618: procutil: delete Python 2 support code
Summary

This entailed deleting a function for Python 2 support and renaming the
Python 3 function to match the exported symbol name.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

indygreg created this revision.Mar 2 2022, 6:31 PM
Alphare accepted this revision.Mar 3 2022, 5:46 AM
This revision is now accepted and ready to land.Mar 3 2022, 5:46 AM
indygreg updated this revision to Diff 32471.Mar 3 2022, 11:09 AM
indygreg added a commit: rHG3681b4c56618: procutil: delete Python 2 support code.Mar 3 2022, 11:56 AM
Closed by commit rHG3681b4c56618: procutil: delete Python 2 support code (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/utils/procutil.py (194 lines)

Diff 32471

mercurial/utils/procutil.py

# pytype: disable=attribute-error # pytype: disable=attribute-error
io.BufferedIOBase.register(LineBufferedWrapper) io.BufferedIOBase.register(LineBufferedWrapper)
# pytype: enable=attribute-error # pytype: enable=attribute-error
def make_line_buffered(stream): def make_line_buffered(stream):
if pycompat.ispy3 and not isinstance(stream, io.BufferedIOBase): if not isinstance(stream, io.BufferedIOBase):
# On Python 3, buffered streams can be expected to subclass # On Python 3, buffered streams can be expected to subclass
# BufferedIOBase. This is definitively the case for the streams # BufferedIOBase. This is definitively the case for the streams
# initialized by the interpreter. For unbuffered streams, we don't need # initialized by the interpreter. For unbuffered streams, we don't need
# to emulate line buffering. # to emulate line buffering.
return stream return stream
if isinstance(stream, LineBufferedWrapper): if isinstance(stream, LineBufferedWrapper):
return stream return stream
return LineBufferedWrapper(stream) return LineBufferedWrapper(stream)
# pytype: disable=attribute-error # pytype: disable=attribute-error
io.IOBase.register(WriteAllWrapper) io.IOBase.register(WriteAllWrapper)
# pytype: enable=attribute-error # pytype: enable=attribute-error
def _make_write_all(stream): def _make_write_all(stream):
assert pycompat.ispy3
if isinstance(stream, WriteAllWrapper): if isinstance(stream, WriteAllWrapper):
return stream return stream
if isinstance(stream, io.BufferedIOBase): if isinstance(stream, io.BufferedIOBase):
# The io.BufferedIOBase.write() contract guarantees that all data is # The io.BufferedIOBase.write() contract guarantees that all data is
# written. # written.
return stream return stream
# In general, the write() method of streams is free to write only part of # In general, the write() method of streams is free to write only part of
# the data. # the data.
return WriteAllWrapper(stream) return WriteAllWrapper(stream)
if pycompat.ispy3:
# Python 3 implements its own I/O streams. Unlike stdio of C library, # Python 3 implements its own I/O streams. Unlike stdio of C library,
# sys.stdin/stdout/stderr may be None if underlying fd is closed. # sys.stdin/stdout/stderr may be None if underlying fd is closed.
# TODO: .buffer might not exist if std streams were replaced; we'll need # TODO: .buffer might not exist if std streams were replaced; we'll need
# a silly wrapper to make a bytes stream backed by a unicode one. # a silly wrapper to make a bytes stream backed by a unicode one.
if sys.stdin is None: if sys.stdin is None:
stdin = BadFile() stdin = BadFile()
else: else:
stdin = sys.stdin.buffer stdin = sys.stdin.buffer
if sys.stdout is None: if sys.stdout is None:
stdout = BadFile() stdout = BadFile()
else: else:
stdout = _make_write_all(sys.stdout.buffer) stdout = _make_write_all(sys.stdout.buffer)
if sys.stderr is None: if sys.stderr is None:
stderr = BadFile() stderr = BadFile()
else: else:
stderr = _make_write_all(sys.stderr.buffer) stderr = _make_write_all(sys.stderr.buffer)
if pycompat.iswindows: if pycompat.iswindows:
# Work around Windows bugs. # Work around Windows bugs.
stdout = platform.winstdout(stdout) # pytype: disable=module-attr stdout = platform.winstdout(stdout) # pytype: disable=module-attr
stderr = platform.winstdout(stderr) # pytype: disable=module-attr stderr = platform.winstdout(stderr) # pytype: disable=module-attr
if isatty(stdout): if isatty(stdout):
# The standard library doesn't offer line-buffered binary streams. # The standard library doesn't offer line-buffered binary streams.
stdout = make_line_buffered(stdout) stdout = make_line_buffered(stdout)
else:
# Python 2 uses the I/O streams provided by the C library.
stdin = sys.stdin
stdout = sys.stdout
stderr = sys.stderr
if pycompat.iswindows:
# Work around Windows bugs.
stdout = platform.winstdout(stdout) # pytype: disable=module-attr
stderr = platform.winstdout(stderr) # pytype: disable=module-attr
if isatty(stdout):
if pycompat.iswindows:
# The Windows C runtime library doesn't support line buffering.
stdout = make_line_buffered(stdout)
else:
# glibc determines buffering on first write to stdout - if we
# replace a TTY destined stdout with a pipe destined stdout (e.g.
# pager), we want line buffering.
stdout = os.fdopen(stdout.fileno(), 'wb', 1)
findexe = platform.findexe findexe = platform.findexe
_gethgcmd = platform.gethgcmd _gethgcmd = platform.gethgcmd
getuser = platform.getuser getuser = platform.getuser
getpid = os.getpid getpid = os.getpid
hidewindow = platform.hidewindow hidewindow = platform.hidewindow
readpipe = platform.readpipe readpipe = platform.readpipe
setbinary = platform.setbinary setbinary = platform.setbinary
record_wait(p.wait) record_wait(p.wait)
finally: finally:
if stdin is not None: if stdin is not None:
stdin.close() stdin.close()
else: else:
def runbgcommandpy3( def runbgcommand(
cmd, cmd,
env, env,
shell=False, shell=False,
stdout=None, stdout=None,
stderr=None, stderr=None,
ensurestart=True, ensurestart=True,
record_wait=None, record_wait=None,
stdin_bytes=None, stdin_bytes=None,
# We use a thread to make the overhead tiny. # We use a thread to make the overhead tiny.
t = threading.Thread(target=lambda: p.wait) t = threading.Thread(target=lambda: p.wait)
t.daemon = True t.daemon = True
t.start() t.start()
else: else:
returncode = p.wait returncode = p.wait
if record_wait is not None: if record_wait is not None:
record_wait(returncode) record_wait(returncode)
def runbgcommandpy2(
cmd,
env,
shell=False,
stdout=None,
stderr=None,
ensurestart=True,
record_wait=None,
stdin_bytes=None,
):
"""Spawn a command without waiting for it to finish.
When `record_wait` is not None, the spawned process will not be fully
detached and the `record_wait` argument will be called with a the
`Subprocess.wait` function for the spawned process. This is mostly
useful for developers that need to make sure the spawned process
finished before a certain point. (eg: writing test)"""
if pycompat.isdarwin:
# avoid crash in CoreFoundation in case another thread
# calls gui() while we're calling fork().
gui()
# double-fork to completely detach from the parent process
# based on http://code.activestate.com/recipes/278731
if record_wait is None:
pid = os.fork()
if pid:
if not ensurestart:
# Even though we're not waiting on the child process,
# we still must call waitpid() on it at some point so
# it's not a zombie/defunct. This is especially relevant for
# chg since the parent process won't die anytime soon.
# We use a thread to make the overhead tiny.
def _do_wait():
os.waitpid(pid, 0)
t = threading.Thread(target=_do_wait)
t.daemon = True
t.start()
return
# Parent process
(_pid, status) = os.waitpid(pid, 0)
if os.WIFEXITED(status):
returncode = os.WEXITSTATUS(status)
else:
returncode = -(os.WTERMSIG(status))
if returncode != 0:
# The child process's return code is 0 on success, an errno
# value on failure, or 255 if we don't have a valid errno
# value.
#
# (It would be slightly nicer to return the full exception info
# over a pipe as the subprocess module does. For now it
# doesn't seem worth adding that complexity here, though.)
if returncode == 255:
returncode = errno.EINVAL
raise OSError(
returncode,
b'error running %r: %s'
% (cmd, os.strerror(returncode)),
)
return
returncode = 255
stdin = None
try:
if record_wait is None:
# Start a new session
os.setsid()
# connect stdin to devnull to make sure the subprocess can't
# muck up that stream for mercurial.
if stdin_bytes is None:
stdin = open(os.devnull, b'r')
else:
stdin = pycompat.unnamedtempfile()
stdin.write(stdin_bytes)
stdin.flush()
stdin.seek(0)
if stdout is None:
stdout = open(os.devnull, b'w')
if stderr is None:
stderr = open(os.devnull, b'w')
p = subprocess.Popen(
cmd,
shell=shell,
env=env,
close_fds=True,
stdin=stdin,
stdout=stdout,
stderr=stderr,
)
if record_wait is not None:
record_wait(p.wait)
returncode = 0
except EnvironmentError as ex:
returncode = ex.errno & 0xFF
if returncode == 0:
# This shouldn't happen, but just in case make sure the
# return code is never 0 here.
returncode = 255
except Exception:
returncode = 255
finally:
# mission accomplished, this child needs to exit and not
# continue the hg process here.
if stdin is not None:
stdin.close()
if record_wait is None:
os._exit(returncode)
if pycompat.ispy3:
# This branch is more robust, because it avoids running python
# code (hence gc finalizers, like sshpeer.__del__, which
# blocks). But we can't easily do the equivalent in py2,
# because of the lack of start_new_session=True flag. Given
# that the py2 branch should die soon, the short-lived
# duplication seems acceptable.
runbgcommand = runbgcommandpy3
else:
runbgcommand = runbgcommandpy2