mirror of
https://github.com/facebook/sapling.git
synced 2024-10-09 00:14:35 +03:00
98d9269874
Summary: Create a fork of the Mercurial code that we can use to build server rpms. The hg servers will continue to exist for a few more months while we move the darkstorm and ediscovery use cases off them. In the mean time, we want to start making breaking changes to the client, so let's create a stable copy of the hg code to produce rpms for the hg servers. The fork is based off c7770c78d, the latest hg release. This copies the files as is, then adds some minor tweaks to get it to build: - Disables some lint checks that appear to be bypassed by path - sed replace eden/scm with eden/hg-server - Removed a dependency on scm/telemetry from the edenfs-client tests since scm/telemetry pulls in the original eden/scm/lib/configparser which conflicts with the hg-server conflict parser. allow-large-files Reviewed By: quark-zju Differential Revision: D27632557 fbshipit-source-id: b2f442f4ec000ea08e4d62de068750832198e1f4
318 lines
11 KiB
Python
318 lines
11 KiB
Python
# Portions Copyright (c) Facebook, Inc. and its affiliates.
|
|
#
|
|
# This software may be used and distributed according to the terms of the
|
|
# GNU General Public License version 2.
|
|
|
|
# demandimport.py - global demand-loading of modules for Mercurial
|
|
#
|
|
# Copyright 2006, 2007 Matt Mackall <mpm@selenic.com>
|
|
#
|
|
# This software may be used and distributed according to the terms of the
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
"""
|
|
demandimport - automatic demandloading of modules
|
|
|
|
To enable this module, do:
|
|
|
|
import demandimport; demandimport.enable()
|
|
|
|
Imports of the following forms will be demand-loaded:
|
|
|
|
import a, b.c
|
|
import a.b as c
|
|
from a import b,c # a will be loaded immediately
|
|
|
|
These imports will not be delayed:
|
|
|
|
from a import *
|
|
b = __import__(a)
|
|
"""
|
|
|
|
from __future__ import absolute_import
|
|
|
|
# pyre-fixme[21]: Could not find `__builtin__`.
|
|
import __builtin__ as builtins
|
|
import contextlib
|
|
import sys
|
|
|
|
|
|
contextmanager = contextlib.contextmanager
|
|
|
|
_origimport = __import__
|
|
|
|
nothing = object()
|
|
|
|
|
|
def _hgextimport(importfunc, name, globals, *args, **kwargs):
|
|
try:
|
|
return importfunc(name, globals, *args, **kwargs)
|
|
except ImportError:
|
|
if not globals:
|
|
raise
|
|
# extensions are loaded with "hgext_" prefix
|
|
hgextname = "hgext_%s" % name
|
|
nameroot = hgextname.split(".", 1)[0]
|
|
contextroot = globals.get("__name__", "").split(".", 1)[0]
|
|
if nameroot != contextroot:
|
|
raise
|
|
# retry to import with "hgext_" prefix
|
|
return importfunc(hgextname, globals, *args, **kwargs)
|
|
|
|
|
|
class _demandmod(object):
|
|
"""module demand-loader and proxy
|
|
|
|
Specify 1 as 'level' argument at construction, to import module
|
|
relatively.
|
|
"""
|
|
|
|
def __init__(self, name, globals, locals, level):
|
|
if "." in name:
|
|
head, rest = name.split(".", 1)
|
|
after = [rest]
|
|
else:
|
|
head = name
|
|
after = []
|
|
object.__setattr__(self, r"_data", (head, globals, locals, after, level, set()))
|
|
object.__setattr__(self, r"_module", None)
|
|
|
|
def _extend(self, name):
|
|
"""add to the list of submodules to load"""
|
|
self._data[3].append(name)
|
|
|
|
def _addref(self, name):
|
|
"""Record that the named module ``name`` imports this module.
|
|
|
|
References to this proxy class having the name of this module will be
|
|
replaced at module load time. We assume the symbol inside the importing
|
|
module is identical to the "head" name of this module. We don't
|
|
actually know if "as X" syntax is being used to change the symbol name
|
|
because this information isn't exposed to __import__.
|
|
"""
|
|
self._data[5].add(name)
|
|
|
|
def _load(self):
|
|
if not self._module:
|
|
head, globals, locals, after, level, modrefs = self._data
|
|
mod = _hgextimport(_origimport, head, globals, locals, None, level)
|
|
if mod is self:
|
|
# In this case, _hgextimport() above should imply
|
|
# _demandimport(). Otherwise, _hgextimport() never
|
|
# returns _demandmod. This isn't intentional behavior,
|
|
# in fact. (see also issue5304 for detail)
|
|
#
|
|
# If self._module is already bound at this point, self
|
|
# should be already _load()-ed while _hgextimport().
|
|
# Otherwise, there is no way to import actual module
|
|
# as expected, because (re-)invoking _hgextimport()
|
|
# should cause same result.
|
|
# This is reason why _load() returns without any more
|
|
# setup but assumes self to be already bound.
|
|
mod = self._module
|
|
assert mod and mod is not self, "%s, %s" % (self, mod)
|
|
return
|
|
|
|
# load submodules
|
|
def subload(mod, p):
|
|
h, t = p, None
|
|
if "." in p:
|
|
h, t = p.split(".", 1)
|
|
if getattr(mod, h, nothing) is nothing:
|
|
setattr(mod, h, _demandmod(p, mod.__dict__, mod.__dict__, level=1))
|
|
elif t:
|
|
subload(getattr(mod, h), t)
|
|
|
|
for x in after:
|
|
subload(mod, x)
|
|
|
|
# Replace references to this proxy instance with the actual module.
|
|
if locals:
|
|
if locals.get(head) is self:
|
|
locals[head] = mod
|
|
elif locals.get(head + r"mod") is self:
|
|
locals[head + r"mod"] = mod
|
|
|
|
for modname in modrefs:
|
|
modref = sys.modules.get(modname, None)
|
|
if modref and getattr(modref, head, None) is self:
|
|
setattr(modref, head, mod)
|
|
|
|
object.__setattr__(self, r"_module", mod)
|
|
|
|
def __repr__(self):
|
|
if self._module:
|
|
return "<proxied module '%s'>" % self._data[0]
|
|
return "<unloaded module '%s'>" % self._data[0]
|
|
|
|
def __call__(self, *args, **kwargs):
|
|
raise TypeError("%s object is not callable" % repr(self))
|
|
|
|
def __getattr__(self, attr):
|
|
self._load()
|
|
return getattr(self._module, attr)
|
|
|
|
def __setattr__(self, attr, val):
|
|
self._load()
|
|
setattr(self._module, attr, val)
|
|
|
|
@property
|
|
def __dict__(self):
|
|
self._load()
|
|
return self._module.__dict__
|
|
|
|
@property
|
|
def __doc__(self):
|
|
self._load()
|
|
return self._module.__doc__
|
|
|
|
|
|
_pypy = "__pypy__" in sys.builtin_module_names
|
|
|
|
|
|
def _demandimport(name, globals=None, locals=None, fromlist=None, level=-1):
|
|
if locals is None or name in ignore or fromlist == ("*",):
|
|
# these cases we can't really delay
|
|
return _hgextimport(_origimport, name, globals, locals, fromlist, level)
|
|
elif not fromlist:
|
|
# import a [as b]
|
|
if "." in name: # a.b
|
|
base, rest = name.split(".", 1)
|
|
# email.__init__ loading email.mime
|
|
if globals and globals.get("__name__", None) == base:
|
|
return _origimport(name, globals, locals, fromlist, level)
|
|
# if a is already demand-loaded, add b to its submodule list
|
|
if base in locals:
|
|
if isinstance(locals[base], _demandmod):
|
|
locals[base]._extend(rest)
|
|
return locals[base]
|
|
return _demandmod(name, globals, locals, level)
|
|
else:
|
|
# There is a fromlist.
|
|
# from a import b,c,d
|
|
# from . import b,c,d
|
|
# from .a import b,c,d
|
|
|
|
# level == -1: relative and absolute attempted (Python 2 only).
|
|
# level >= 0: absolute only (Python 2 w/ absolute_import and Python 3).
|
|
# The modern Mercurial convention is to use absolute_import everywhere,
|
|
# so modern Mercurial code will have level >= 0.
|
|
|
|
# The name of the module the import statement is located in.
|
|
globalname = globals.get("__name__")
|
|
|
|
def processfromitem(mod, attr):
|
|
"""Process an imported symbol in the import statement.
|
|
|
|
If the symbol doesn't exist in the parent module, and if the
|
|
parent module is a package, it must be a module. We set missing
|
|
modules up as _demandmod instances.
|
|
"""
|
|
symbol = getattr(mod, attr, nothing)
|
|
nonpkg = getattr(mod, "__path__", nothing) is nothing
|
|
if symbol is nothing:
|
|
if nonpkg:
|
|
# do not try relative import, which would raise ValueError,
|
|
# and leave unknown attribute as the default __import__()
|
|
# would do. the missing attribute will be detected later
|
|
# while processing the import statement.
|
|
return
|
|
mn = "%s.%s" % (mod.__name__, attr)
|
|
if mn in ignore:
|
|
importfunc = _origimport
|
|
else:
|
|
importfunc = _demandmod
|
|
symbol = importfunc(attr, mod.__dict__, locals, level=1)
|
|
setattr(mod, attr, symbol)
|
|
|
|
# Record the importing module references this symbol so we can
|
|
# replace the symbol with the actual module instance at load
|
|
# time.
|
|
if globalname and isinstance(symbol, _demandmod):
|
|
symbol._addref(globalname)
|
|
|
|
def chainmodules(rootmod, modname):
|
|
# recurse down the module chain, and return the leaf module
|
|
mod = rootmod
|
|
for comp in modname.split(".")[1:]:
|
|
obj = getattr(mod, comp, nothing)
|
|
if obj is nothing:
|
|
obj = _demandmod(comp, mod.__dict__, mod.__dict__, level=1)
|
|
setattr(mod, comp, obj)
|
|
elif mod.__name__ + "." + comp in sys.modules:
|
|
# prefer loaded module over attribute (issue5617)
|
|
obj = sys.modules[mod.__name__ + "." + comp]
|
|
mod = obj
|
|
return mod
|
|
|
|
if level >= 0:
|
|
if name:
|
|
# "from a import b" or "from .a import b" style
|
|
rootmod = _hgextimport(_origimport, name, globals, locals, level=level)
|
|
mod = chainmodules(rootmod, name)
|
|
elif _pypy:
|
|
# PyPy's __import__ throws an exception if invoked
|
|
# with an empty name and no fromlist. Recreate the
|
|
# desired behaviour by hand.
|
|
mn = globalname
|
|
mod = sys.modules[mn]
|
|
if getattr(mod, "__path__", nothing) is nothing:
|
|
mn = mn.rsplit(".", 1)[0]
|
|
mod = sys.modules[mn]
|
|
if level > 1:
|
|
mn = mn.rsplit(".", level - 1)[0]
|
|
mod = sys.modules[mn]
|
|
else:
|
|
mod = _hgextimport(_origimport, name, globals, locals, level=level)
|
|
|
|
for x in fromlist:
|
|
processfromitem(mod, x)
|
|
|
|
return mod
|
|
|
|
# But, we still need to support lazy loading of standard library and 3rd
|
|
# party modules. So handle level == -1.
|
|
mod = _hgextimport(_origimport, name, globals, locals)
|
|
mod = chainmodules(mod, name)
|
|
|
|
for x in fromlist:
|
|
processfromitem(mod, x)
|
|
|
|
return mod
|
|
|
|
|
|
ignore = set()
|
|
|
|
|
|
def init(ignorelist):
|
|
global ignore
|
|
ignore = set(ignorelist)
|
|
|
|
|
|
def isenabled():
|
|
return builtins.__import__ == _demandimport
|
|
|
|
|
|
def enable():
|
|
"enable global demand-loading of modules"
|
|
builtins.__import__ = _demandimport
|
|
|
|
|
|
def disable():
|
|
"disable global demand-loading of modules"
|
|
builtins.__import__ = _origimport
|
|
|
|
|
|
@contextmanager
|
|
def deactivated():
|
|
"context manager for disabling demandimport in 'with' blocks"
|
|
demandenabled = isenabled()
|
|
if demandenabled:
|
|
disable()
|
|
|
|
try:
|
|
yield
|
|
finally:
|
|
if demandenabled:
|
|
enable()
|