This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7584

procutil: add a option to not fully detach background process
ClosedPublic

Authored by marmoute on Dec 9 2019, 8:02 AM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG15a6c6783060: procutil: add a option to not fully detach background process
Summary

When writing test, it is useful to make code pretending to spawn a fully
detached process while still actually waiting for it to finish. We add the
option to procutil.runbgcommand, to do so. We will use this in remote-filelog
tests.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Dec 9 2019, 8:02 AM

target is the stable-branch

durin42 requested changes to this revision.Dec 9 2019, 10:14 AM
durin42 added a subscriber: durin42.
durin42 added inline comments.
mercurial/utils/procutil.py
589

s/register_wait/record_wait/?

592

s/developper/developers/

This revision now requires changes to proceed.Dec 9 2019, 10:14 AM
marmoute updated this revision to Diff 18556.Dec 9 2019, 10:51 AM
marmoute added a commit: rHG15a6c6783060: procutil: add a option to not fully detach background process.Dec 11 2019, 12:28 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG15a6c6783060: procutil: add a option to not fully detach background process (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

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

Diff 18609

mercurial/utils/procutil.py

# No stdlib constant exists for this value # No stdlib constant exists for this value
DETACHED_PROCESS = 0x00000008 DETACHED_PROCESS = 0x00000008
# Following creation flags might create a console GUI window. # Following creation flags might create a console GUI window.
# Using subprocess.CREATE_NEW_CONSOLE might helps. # Using subprocess.CREATE_NEW_CONSOLE might helps.
# See https://phab.mercurial-scm.org/D1701 for discussion # See https://phab.mercurial-scm.org/D1701 for discussion
_creationflags = DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP _creationflags = DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
def runbgcommand( def runbgcommand(
script, env, shell=False, stdout=None, stderr=None, ensurestart=True script,
env,
shell=False,
stdout=None,
stderr=None,
ensurestart=True,
record_wait=None,
): ):
'''Spawn a command without waiting for it to finish.''' '''Spawn a command without waiting for it to finish.'''
# we can't use close_fds *and* redirect stdin. I'm not sure that we # we can't use close_fds *and* redirect stdin. I'm not sure that we
# need to because the detached process has no console connection. # need to because the detached process has no console connection.
subprocess.Popen( p = subprocess.Popen(
tonativestr(script), tonativestr(script),
shell=shell, shell=shell,
env=tonativeenv(env), env=tonativeenv(env),
close_fds=True, close_fds=True,
creationflags=_creationflags, creationflags=_creationflags,
stdout=stdout, stdout=stdout,
stderr=stderr, stderr=stderr,
) )
if record_wait is not None:
record_wait(p.wait)
else: else:
def runbgcommand( def runbgcommand(
cmd, env, shell=False, stdout=None, stderr=None, ensurestart=True cmd,
env,
shell=False,
stdout=None,
stderr=None,
ensurestart=True,
record_wait=None,
): ):
'''Spawn a command without waiting for it to finish.''' '''Spawn a command without waiting for it to finish.
When `record_wait` is not None, the spawned process will not be fully
durin42Unsubmitted
Not Done

s/register_wait/record_wait/?

durin42: s/register_wait/record_wait/?
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
durin42Unsubmitted
Not Done

s/developper/developers/

durin42: s/developper/developers/
finished before a certain point. (eg: writing test)'''
# double-fork to completely detach from the parent process # double-fork to completely detach from the parent process
# based on http://code.activestate.com/recipes/278731 # based on http://code.activestate.com/recipes/278731
if record_wait is None:
pid = os.fork() pid = os.fork()
if pid: if pid:
if not ensurestart: if not ensurestart:
return return
# Parent process # Parent process
(_pid, status) = os.waitpid(pid, 0) (_pid, status) = os.waitpid(pid, 0)
if os.WIFEXITED(status): if os.WIFEXITED(status):
returncode = os.WEXITSTATUS(status) returncode = os.WEXITSTATUS(status)
else: else:
returncode = -(os.WTERMSIG(status)) returncode = -(os.WTERMSIG(status))
if returncode != 0: if returncode != 0:
# The child process's return code is 0 on success, an errno # 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 on failure, or 255 if we don't have a valid errno
# value. # value.
# #
# (It would be slightly nicer to return the full exception info # (It would be slightly nicer to return the full exception info
# over a pipe as the subprocess module does. For now it # over a pipe as the subprocess module does. For now it
# doesn't seem worth adding that complexity here, though.) # doesn't seem worth adding that complexity here, though.)
if returncode == 255: if returncode == 255:
returncode = errno.EINVAL returncode = errno.EINVAL
raise OSError( raise OSError(
returncode, returncode,
b'error running %r: %s' % (cmd, os.strerror(returncode)), b'error running %r: %s'
% (cmd, os.strerror(returncode)),
) )
return return
returncode = 255 returncode = 255
try: try:
if record_wait is None:
# Start a new session # Start a new session
os.setsid() os.setsid()
stdin = open(os.devnull, b'r') stdin = open(os.devnull, b'r')
if stdout is None: if stdout is None:
stdout = open(os.devnull, b'w') stdout = open(os.devnull, b'w')
if stderr is None: if stderr is None:
stderr = open(os.devnull, b'w') stderr = open(os.devnull, b'w')
# connect stdin to devnull to make sure the subprocess can't # connect stdin to devnull to make sure the subprocess can't
# muck up that stream for mercurial. # muck up that stream for mercurial.
subprocess.Popen( p = subprocess.Popen(
cmd, cmd,
shell=shell, shell=shell,
env=env, env=env,
close_fds=True, close_fds=True,
stdin=stdin, stdin=stdin,
stdout=stdout, stdout=stdout,
stderr=stderr, stderr=stderr,
) )
if record_wait is not None:
record_wait(p.wait)
returncode = 0 returncode = 0
except EnvironmentError as ex: except EnvironmentError as ex:
returncode = ex.errno & 0xFF returncode = ex.errno & 0xFF
if returncode == 0: if returncode == 0:
# This shouldn't happen, but just in case make sure the # This shouldn't happen, but just in case make sure the
# return code is never 0 here. # return code is never 0 here.
returncode = 255 returncode = 255
except Exception: except Exception:
returncode = 255 returncode = 255
finally: finally:
# mission accomplished, this child needs to exit and not # mission accomplished, this child needs to exit and not
# continue the hg process here. # continue the hg process here.
if record_wait is None:
os._exit(returncode) os._exit(returncode)