mirror of
https://github.com/facebook/sapling.git
synced 2024-10-09 08:18:15 +03:00
57ef465cca
Signals could be blocked by something like:
#include <unistd.h>
#include <signal.h>
int main(int argc, char * const argv[]) {
sigset_t set;
sigfillset(&set);
sigprocmask(SIG_BLOCK, &set, NULL);
execv("/bin/hg", argv);
return 0;
}
One of the problems is if SIGCHLD is blocked, chgserver would not reap
zombie workers since it depends on SIGCHLD handler entirely.
While it's the parent process to blame but it seems a good idea to just
unblock the signal from hg. FWIW git does that for SIGPIPE already [1].
Unfortunately Python 2 does not reset or provide APIs to change signal
masks. Therefore let's add one in osutil. Note: Python 3.3 introduced
`signal.pthread_sigmask` which solves the problem.
`sigprocmask` is part of POSIX [2] so there is no feature testing in
`setup.py`.
[1]: 7559a1be8a
[2]: http://pubs.opengroup.org/onlinepubs/7908799/xsh/sigprocmask.html
Differential Revision: https://phab.mercurial-scm.org/D1736
117 lines
3.8 KiB
Python
117 lines
3.8 KiB
Python
# policy.py - module policy logic for Mercurial.
|
|
#
|
|
# Copyright 2015 Gregory Szorc <gregory.szorc@gmail.com>
|
|
#
|
|
# This software may be used and distributed according to the terms of the
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
from __future__ import absolute_import
|
|
|
|
import os
|
|
import sys
|
|
|
|
# Rules for how modules can be loaded. Values are:
|
|
#
|
|
# c - require C extensions
|
|
# allow - allow pure Python implementation when C loading fails
|
|
# cffi - required cffi versions (implemented within pure module)
|
|
# cffi-allow - allow pure Python implementation if cffi version is missing
|
|
# py - only load pure Python modules
|
|
#
|
|
# By default, fall back to the pure modules so the in-place build can
|
|
# run without recompiling the C extensions. This will be overridden by
|
|
# __modulepolicy__ generated by setup.py.
|
|
policy = b'allow'
|
|
_packageprefs = {
|
|
# policy: (versioned package, pure package)
|
|
b'c': (r'cext', None),
|
|
b'allow': (r'cext', r'pure'),
|
|
b'cffi': (r'cffi', None),
|
|
b'cffi-allow': (r'cffi', r'pure'),
|
|
b'py': (None, r'pure'),
|
|
}
|
|
|
|
try:
|
|
from . import __modulepolicy__
|
|
policy = __modulepolicy__.modulepolicy
|
|
except ImportError:
|
|
pass
|
|
|
|
# PyPy doesn't load C extensions.
|
|
#
|
|
# The canonical way to do this is to test platform.python_implementation().
|
|
# But we don't import platform and don't bloat for it here.
|
|
if r'__pypy__' in sys.builtin_module_names:
|
|
policy = b'cffi'
|
|
|
|
# Our C extensions aren't yet compatible with Python 3. So use pure Python
|
|
# on Python 3 for now.
|
|
if sys.version_info[0] >= 3:
|
|
policy = b'py'
|
|
|
|
# Environment variable can always force settings.
|
|
if sys.version_info[0] >= 3:
|
|
if r'HGMODULEPOLICY' in os.environ:
|
|
policy = os.environ[r'HGMODULEPOLICY'].encode(r'utf-8')
|
|
else:
|
|
policy = os.environ.get(r'HGMODULEPOLICY', policy)
|
|
|
|
def _importfrom(pkgname, modname):
|
|
# from .<pkgname> import <modname> (where . is looked through this module)
|
|
fakelocals = {}
|
|
pkg = __import__(pkgname, globals(), fakelocals, [modname], level=1)
|
|
try:
|
|
fakelocals[modname] = mod = getattr(pkg, modname)
|
|
except AttributeError:
|
|
raise ImportError(r'cannot import name %s' % modname)
|
|
# force import; fakelocals[modname] may be replaced with the real module
|
|
getattr(mod, r'__doc__', None)
|
|
return fakelocals[modname]
|
|
|
|
# keep in sync with "version" in C modules
|
|
_cextversions = {
|
|
(r'cext', r'base85'): 1,
|
|
(r'cext', r'bdiff'): 1,
|
|
(r'cext', r'diffhelpers'): 1,
|
|
(r'cext', r'mpatch'): 1,
|
|
(r'cext', r'osutil'): 2,
|
|
(r'cext', r'parsers'): 4,
|
|
}
|
|
|
|
# map import request to other package or module
|
|
_modredirects = {
|
|
(r'cext', r'charencode'): (r'cext', r'parsers'),
|
|
(r'cffi', r'base85'): (r'pure', r'base85'),
|
|
(r'cffi', r'charencode'): (r'pure', r'charencode'),
|
|
(r'cffi', r'diffhelpers'): (r'pure', r'diffhelpers'),
|
|
(r'cffi', r'parsers'): (r'pure', r'parsers'),
|
|
}
|
|
|
|
def _checkmod(pkgname, modname, mod):
|
|
expected = _cextversions.get((pkgname, modname))
|
|
actual = getattr(mod, r'version', None)
|
|
if actual != expected:
|
|
raise ImportError(r'cannot import module %s.%s '
|
|
r'(expected version: %d, actual: %r)'
|
|
% (pkgname, modname, expected, actual))
|
|
|
|
def importmod(modname):
|
|
"""Import module according to policy and check API version"""
|
|
try:
|
|
verpkg, purepkg = _packageprefs[policy]
|
|
except KeyError:
|
|
raise ImportError(r'invalid HGMODULEPOLICY %r' % policy)
|
|
assert verpkg or purepkg
|
|
if verpkg:
|
|
pn, mn = _modredirects.get((verpkg, modname), (verpkg, modname))
|
|
try:
|
|
mod = _importfrom(pn, mn)
|
|
if pn == verpkg:
|
|
_checkmod(pn, mn, mod)
|
|
return mod
|
|
except ImportError:
|
|
if not purepkg:
|
|
raise
|
|
pn, mn = _modredirects.get((purepkg, modname), (purepkg, modname))
|
|
return _importfrom(pn, mn)
|