This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4938

remotefilelog: transplant runbgcommand to procutil
ClosedPublic

Authored by durin42 on Oct 11 2018, 8:21 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG3fbfbc8c9f82: remotefilelog: transplant runbgcommand to procutil
Summary

While cleaning up the deprecated runshellcommand I noticed a
near-clone of this in logtoprocess, so I'm standardizing on what
appears to be the newer one by moving it to procutil.

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.

Revision Contents
Changeset List

Diff 12409

hgext/remotefilelog/extutil.py

# extutil.py - useful utility methods for extensions # extutil.py - useful utility methods for extensions
# #
# Copyright 2016 Facebook # Copyright 2016 Facebook
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import errno import errno
import os import os
import subprocess
import time import time
from mercurial import ( from mercurial import (
error, error,
lock as lockmod, lock as lockmod,
pycompat,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
if pycompat.iswindows:
# no fork on Windows, but we can create a detached process
# https://msdn.microsoft.com/en-us/library/windows/desktop/ms684863.aspx
# No stdlib constant exists for this value
DETACHED_PROCESS = 0x00000008
_creationflags = DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
def runbgcommand(script, env, shell=False, stdout=None, stderr=None):
'''Spawn a command without waiting for it to finish.'''
# 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.
subprocess.Popen(
script, shell=shell, env=env, close_fds=True,
creationflags=_creationflags, stdout=stdout, stderr=stderr)
else:
def runbgcommand(cmd, env, shell=False, stdout=None, stderr=None):
'''Spawn a command without waiting for it to finish.'''
# double-fork to completely detach from the parent process
# based on http://code.activestate.com/recipes/278731
pid = os.fork()
if pid:
# 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, 'error running %r: %s' %
(cmd, os.strerror(returncode)))
return
returncode = 255
try:
# Start a new session
os.setsid()
stdin = open(os.devnull, 'r')
if stdout is None:
stdout = open(os.devnull, 'w')
if stderr is None:
stderr = open(os.devnull, 'w')
# connect stdin to devnull to make sure the subprocess can't
# muck up that stream for mercurial.
subprocess.Popen(
cmd, shell=shell, env=env, close_fds=True,
stdin=stdin, stdout=stdout, stderr=stderr)
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.
os._exit(returncode)
@contextlib.contextmanager @contextlib.contextmanager
def flock(lockpath, description, timeout=-1): def flock(lockpath, description, timeout=-1):
"""A flock based lock object. Currently it is always non-blocking. """A flock based lock object. Currently it is always non-blocking.
Note that since it is flock based, you can accidentally take it multiple Note that since it is flock based, you can accidentally take it multiple
times within one process and the first one to be released will release all times within one process and the first one to be released will release all
of them. So the caller needs to be careful to not create more than one of them. So the caller needs to be careful to not create more than one
instance per lock. instance per lock.

hgext/remotefilelog/repack.py

cmd = [_hgexecutable(), '-R', repo.origroot, 'repack'] cmd = [_hgexecutable(), '-R', repo.origroot, 'repack']
msg = _("(running background repack)\n") msg = _("(running background repack)\n")
if incremental: if incremental:
cmd.append('--incremental') cmd.append('--incremental')
msg = _("(running background incremental repack)\n") msg = _("(running background incremental repack)\n")
if packsonly: if packsonly:
cmd.append('--packsonly') cmd.append('--packsonly')
repo.ui.warn(msg) repo.ui.warn(msg)
extutil.runbgcommand(cmd, encoding.environ) procutil.runbgcommand(cmd, encoding.environ)
def fullrepack(repo, options=None): def fullrepack(repo, options=None):
"""If ``packsonly`` is True, stores creating only loose objects are skipped. """If ``packsonly`` is True, stores creating only loose objects are skipped.
""" """
if util.safehasattr(repo, 'shareddatastores'): if util.safehasattr(repo, 'shareddatastores'):
datasource = contentstore.unioncontentstore( datasource = contentstore.unioncontentstore(
*repo.shareddatastores) *repo.shareddatastores)
historysource = metadatastore.unionmetadatastore( historysource = metadatastore.unionmetadatastore(

hgext/remotefilelog/shallowrepo.py

util, util,
) )
from mercurial.utils import procutil from mercurial.utils import procutil
from . import ( from . import (
connectionpool, connectionpool,
constants, constants,
contentstore, contentstore,
datapack, datapack,
extutil,
fileserverclient, fileserverclient,
historypack, historypack,
metadatastore, metadatastore,
remotefilectx, remotefilectx,
remotefilelog, remotefilelog,
shallowutil, shallowutil,
) )
opts=None): opts=None):
"""Runs prefetch in background with optional repack """Runs prefetch in background with optional repack
""" """
cmd = [_hgexecutable(), '-R', repo.origroot, 'prefetch'] cmd = [_hgexecutable(), '-R', repo.origroot, 'prefetch']
if repack: if repack:
cmd.append('--repack') cmd.append('--repack')
if revs: if revs:
cmd += ['-r', revs] cmd += ['-r', revs]
extutil.runbgcommand(cmd, encoding.environ) procutil.runbgcommand(cmd, encoding.environ)
def prefetch(self, revs, base=None, pats=None, opts=None): def prefetch(self, revs, base=None, pats=None, opts=None):
"""Prefetches all the necessary file revisions for the given revs """Prefetches all the necessary file revisions for the given revs
Optionally runs repack in background Optionally runs repack in background
""" """
with repo._lock(repo.svfs, 'prefetchlock', True, None, None, with repo._lock(repo.svfs, 'prefetchlock', True, None, None,
_('prefetching in %s') % repo.origroot): _('prefetching in %s') % repo.origroot):
self._prefetch(revs, base, pats, opts) self._prefetch(revs, base, pats, opts)

mercurial/utils/procutil.py

# procutil.py - utility for managing processes and executable environment # procutil.py - utility for managing processes and executable environment
# #
# Copyright 2005 K. Thananchayan <thananck@yahoo.com> # Copyright 2005 K. Thananchayan <thananck@yahoo.com>
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import errno
import imp import imp
import io import io
import os import os
import signal import signal
import subprocess import subprocess
import sys import sys
import time import time
# wrong thread, oh well, we tried # wrong thread, oh well, we tried
del oldsiginthandler[0] del oldsiginthandler[0]
yield yield
finally: finally:
if oldsiginthandler: if oldsiginthandler:
signal.signal(signal.SIGINT, oldsiginthandler[0]) signal.signal(signal.SIGINT, oldsiginthandler[0])
if shouldbail: if shouldbail:
raise KeyboardInterrupt raise KeyboardInterrupt
if pycompat.iswindows:
# no fork on Windows, but we can create a detached process
# https://msdn.microsoft.com/en-us/library/windows/desktop/ms684863.aspx
# No stdlib constant exists for this value
DETACHED_PROCESS = 0x00000008
_creationflags = DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
def runbgcommand(script, env, shell=False, stdout=None, stderr=None):
'''Spawn a command without waiting for it to finish.'''
# 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.
subprocess.Popen(
script, shell=shell, env=env, close_fds=True,
creationflags=_creationflags, stdout=stdout, stderr=stderr)
else:
def runbgcommand(cmd, env, shell=False, stdout=None, stderr=None):
'''Spawn a command without waiting for it to finish.'''
# double-fork to completely detach from the parent process
# based on http://code.activestate.com/recipes/278731
pid = os.fork()
if pid:
# 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, 'error running %r: %s' %
(cmd, os.strerror(returncode)))
return
returncode = 255
try:
# Start a new session
os.setsid()
stdin = open(os.devnull, 'r')
if stdout is None:
stdout = open(os.devnull, 'w')
if stderr is None:
stderr = open(os.devnull, 'w')
# connect stdin to devnull to make sure the subprocess can't
# muck up that stream for mercurial.
subprocess.Popen(
cmd, shell=shell, env=env, close_fds=True,
stdin=stdin, stdout=stdout, stderr=stderr)
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.
os._exit(returncode)