def __init__(self, install_dir, *args, **kwargs):
"""Produce a module finder that ignores PYTHONPATH and only
reports the direct imports of a module.
run_paths as a keyword argument specifies a list of additional
paths to use when searching for modules."""
# ModuleFinder.__init__ doesn't expect run_paths
run_paths = kwargs.pop("run_paths", [])
# Check to see whether a python path has been set.
if python_path in os.environ:
py_path = [os.path.normpath(fp) for fp in os.environ[python_path].split(os.pathsep)]
else:
py_path = []
# Remove any paths that start with the defined python paths.
new_path = [fp for fp in sys.path[1:] if not self.startswith_path(fp, py_path)]
new_path.append(install_dir)
if run_paths:
# add our detected runpath into the user-supplied one
# (if any)
new_path = base.insert_default_runpath(new_path, run_paths)
modulefinder.ModuleFinder.__init__(self, path=new_path, *args, **kwargs)
def __init__(self, install_dir, *args, **kwargs):
"""Produce a module finder that ignores PYTHONPATH and only
reports the direct imports of a module.
run_paths as a keyword argument specifies a list of additional
paths to use when searching for modules."""
# ModuleFinder.__init__ doesn't expect run_paths
run_paths = kwargs.pop("run_paths", [])
# Check to see whether a python path has been set.
if python_path in os.environ:
py_path = [
os.path.normpath(fp)
for fp in os.environ[python_path].split(os.pathsep)
]
else:
py_path = []
# Remove any paths that start with the defined python paths.
new_path = [
fp
for fp in sys.path[1:]
if not self.startswith_path(fp, py_path)
]
new_path.append(install_dir)
if run_paths:
if __name__ != "__main__":
# add our detected runpath into the
# user-supplied one (if any)
new_path = base.insert_default_runpath(new_path,
run_paths)
else:
# This is a copy of the above function call.
# insert our default search path where the
# PD_DEFAULT_RUNPATH token was found
try:
index = run_paths.index(
PD_DEFAULT_RUNPATH)
run_paths = run_paths[:index] + \
new_path + run_paths[index + 1:]
if PD_DEFAULT_RUNPATH in run_paths:
raise MultipleDefaultRunPaths()
except ValueError:
# no PD_DEFAULT_PATH token, so we
# override the whole default search path
pass
new_path = run_paths
modulefinder.ModuleFinder.__init__(self, path=new_path,
*args, **kwargs)
def process_elf_dependencies(action, pkg_vars, dyn_tok_conv, run_paths,
**kwargs):
"""Produce the elf dependencies for the file delivered in the action
provided.
'action' is the file action to analyze.
'pkg_vars' is the list of variants against which the package delivering
the action was published.
'dyn_tok_conv' is the dictionary which maps the dynamic tokens, like
$PLATFORM, to the values they should be expanded to.
'run_paths' contains the run paths which elf binaries should use.
"""
if not action.name == "file":
return [], [], {}
installed_path = action.attrs[action.key_attr]
proto_file = action.attrs[PD_LOCAL_PATH]
if not os.path.exists(proto_file):
raise base.MissingFile(proto_file)
if not elf.is_elf_object(proto_file):
return [], [], {}
try:
ei = elf.get_info(proto_file)
ed = elf.get_dynamic(proto_file)
except elf.ElfError as e:
raise BadElfFile(proto_file, e)
deps = [
d[0]
for d in ed.get("deps", [])
]
rp = ed.get("runpath", "").split(":")
if len(rp) == 1 and rp[0] == "":
rp = []
dyn_tok_conv["$ORIGIN"] = [os.path.join("/",
os.path.dirname(installed_path))]
kernel64 = None
# For kernel modules, default path resolution is /platform/<platform>,
# /kernel, /usr/kernel. But how do we know what <platform> would be for
# a given module? Does it do fallbacks to, say, sun4u?
if installed_path.startswith("kernel") or \
installed_path.startswith("usr/kernel") or \
(installed_path.startswith("platform") and \
installed_path.split("/")[2] == "kernel"):
if rp and (len(rp) > 1 or
not re.match(r'^/usr/gcc/\d/lib$', rp[0])):
raise RuntimeError("RUNPATH set for kernel module "
"({0}): {1}".format(installed_path, rp))
# Add this platform to the search path.
if installed_path.startswith("platform"):
rp.append("/platform/{0}/kernel".format(
installed_path.split("/")[1]))
else:
for p in dyn_tok_conv.get("$PLATFORM", []):
rp.append("/platform/{0}/kernel".format(p))
# Default kernel search path
rp.extend(["/kernel", "/usr/kernel"])
# What subdirectory should we look in for 64-bit kernel modules?
if ei["bits"] == 64:
if ei["arch"] == "i386":
kernel64 = "amd64"
elif ei["arch"] == "sparc":
kernel64 = "sparcv9"
else:
raise RuntimeError("Unknown arch:{0}".format(
ei["arch"]))
else:
for p in default_run_paths:
if ei["bits"] == 64:
p += "/64"
if p not in rp:
rp.append(p)
elist = []
if run_paths:
# add our detected runpaths into the user-supplied one (if any)
rp = base.insert_default_runpath(rp, run_paths)
rp, errs = expand_variables(rp, dyn_tok_conv)
elist.extend([
UnsupportedDynamicToken(proto_file, installed_path, p, tok)
for p, tok in errs
])
res = []
for d in deps:
pn, fn = os.path.split(d)
pathlist = []
for p in rp:
if kernel64:
# Find 64-bit modules the way krtld does.
# XXX We don't resolve dependencies found in
# /platform, since we don't know where under
# /platform to look.
deppath = \
os.path.join(p, pn, kernel64, fn).lstrip(
os.path.sep)
else:
deppath = os.path.join(p, d).lstrip(os.path.sep)
# deppath includes filename; remove that.
head, tail = os.path.split(deppath)
if head:
pathlist.append(head)
res.append(ElfDependency(action, fn, pathlist, pkg_vars,
action.attrs[PD_PROTO_DIR]))
del dyn_tok_conv["$ORIGIN"]
return res, elist, {}
elif ei["arch"] == "sparc":
kernel64 = "sparcv9"
else:
raise RuntimeError("Unknown arch:%s" %
ei["arch"])
else:
for p in default_run_paths:
if ei["bits"] == 64:
p += "/64"
if p not in rp:
rp.append(p)
elist = []
if run_paths:
# add our detected runpaths into the user-supplied one (if any)
rp = base.insert_default_runpath(rp, run_paths)
rp, errs = expand_variables(rp, dyn_tok_conv)
elist.extend([
UnsupportedDynamicToken(proto_file, installed_path, p, tok)
for p, tok in errs
])
res = []
for d in deps:
pn, fn = os.path.split(d)
pathlist = []
for p in rp:
if kernel64:
