drgn/setup.py
Omar Sandoval 4c5c5f3842 Remove bundled version of elfutils
We currently bundle a version of elfutils with patches to export
additional stack tracing functionality. This has a few drawbacks:

- Most of drgn's build time is actually building elfutils.
- Distributions don't like packages that bundle verions of other
  packages.
- elfutils, and thus drgn, can't be built with clang.

Now that we've replaced the elfutils DWARF unwinder with our own, we
don't need the patches, so we can drop the bundled elfutils and fix
these issues.

Signed-off-by: Omar Sandoval <osandov@osandov.com>
2021-03-16 00:52:09 -07:00

363 lines
12 KiB
Python
Executable File

#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# SPDX-License-Identifier: GPL-3.0+
# setuptools must be imported before distutils (see pypa/setuptools#2230).
import setuptools # isort: skip
import contextlib
from distutils import log
from distutils.command.build import build as _build
from distutils.dir_util import mkpath
from distutils.errors import DistutilsError
from distutils.file_util import copy_file
import os
import os.path
import re
import shlex
import subprocess
import sys
from setuptools import Command, find_packages, setup
from setuptools.command.build_ext import build_ext as _build_ext
from setuptools.command.egg_info import egg_info as _egg_info
from setuptools.extension import Extension
from util import nproc, out_of_date
class build(_build):
def finalize_options(self):
super().finalize_options()
if self.parallel is None:
self.parallel = nproc() + 1
class build_ext(_build_ext):
user_options = [
("inplace", "i", "put compiled extension into the source directory"),
("parallel=", "j", "number of parallel build jobs"),
]
boolean_options = ["inplace"]
help_options = []
def _run_autoreconf(self, dir):
configure = os.path.join(dir, "configure")
configure_ac = os.path.join(dir, "configure.ac")
makefile_am = os.path.join(dir, "Makefile.am")
makefile_in = os.path.join(dir, "Makefile.in")
if out_of_date(makefile_in, makefile_am, configure_ac) or out_of_date(
configure, configure_ac
):
try:
subprocess.check_call(["autoreconf", "-i", dir])
except Exception:
with contextlib.suppress(FileNotFoundError):
os.remove(configure)
with contextlib.suppress(FileNotFoundError):
os.remove(makefile_in)
raise
def _run_configure(self):
mkpath(self.build_temp)
makefile = os.path.join(self.build_temp, "Makefile")
if not os.path.exists(makefile):
args = [
os.path.relpath("libdrgn/configure", self.build_temp),
"--disable-static",
"--with-python=" + sys.executable,
]
try:
args.extend(shlex.split(os.environ["CONFIGURE_FLAGS"]))
except KeyError:
pass
try:
subprocess.check_call(args, cwd=self.build_temp)
except Exception:
with contextlib.suppress(FileNotFoundError):
os.remove(makefile)
raise
def _run_make(self):
args = ["make", "-C", self.build_temp]
if self.parallel:
args.append(f"-j{self.parallel}")
subprocess.check_call(args)
def run(self):
self._run_autoreconf("libdrgn")
self._run_configure()
self._run_make()
so = os.path.join(self.build_temp, ".libs/_drgn.so")
if self.inplace:
copy_file(so, self.get_ext_fullpath("_drgn"), update=True)
old_inplace, self.inplace = self.inplace, 0
build_path = self.get_ext_fullpath("_drgn")
mkpath(os.path.dirname(build_path))
copy_file(so, build_path, update=True)
self.inplace = old_inplace
def get_source_files(self):
if os.path.exists(".git"):
args = ["git", "ls-files", "-z", "libdrgn"]
return [
os.fsdecode(path)
for path in subprocess.check_output(args).split(b"\0")
if path
]
else:
# If this is a source distribution, then setuptools will get the
# list of sources that was included in the tarball.
return []
# Work around pypa/setuptools#436.
class egg_info(_egg_info):
def run(self):
if os.path.exists(".git"):
with contextlib.suppress(FileNotFoundError):
os.remove(os.path.join(self.egg_info, "SOURCES.txt"))
super().run()
class test(Command):
description = "run unit tests after in-place build"
KERNELS = [
"5.12",
"5.11",
"5.10",
"5.9",
"5.8",
"5.7",
"5.6",
"5.4",
"4.19",
"4.14",
"4.9",
"4.4",
]
user_options = [
(
"kernel",
"K",
"run Linux kernel helper tests in a virtual machine on all supported kernels "
f"({', '.join(KERNELS)})",
),
(
"extra-kernels=",
"k",
"additional kernels to run Linux kernel helper tests on in a virtual machine "
"(comma-separated list of wildcard patterns matching uploaded kernel releases)",
),
(
"vmtest-dir=",
"d",
"directory for built artifacts and downloaded kernels for virtual machine tests (default: 'build/vmtest')",
),
]
def initialize_options(self):
self.kernel = False
self.extra_kernels = ""
self.vmtest_dir = None
def finalize_options(self):
self.kernels = [kernel for kernel in self.extra_kernels.split(",") if kernel]
if self.kernel:
self.kernels.extend(kernel + ".*" for kernel in test.KERNELS)
if self.vmtest_dir is None:
build_base = self.get_finalized_command("build").build_base
self.vmtest_dir = os.path.join(build_base, "vmtest")
def _run_local(self):
import unittest
argv = ["discover"]
if self.verbose:
argv.append("-v")
test = unittest.main(module=None, argv=argv, exit=False)
return test.result.wasSuccessful()
def _run_vm(self, kernel_dir):
from pathlib import Path
import vmtest.vm
command = fr"""cd {shlex.quote(os.getcwd())} &&
DRGN_RUN_LINUX_HELPER_TESTS=1 {shlex.quote(sys.executable)} -Bm \
unittest discover -t . -s tests/helpers/linux {"-v" if self.verbose else ""}"""
try:
returncode = vmtest.vm.run_in_vm(
command, Path(kernel_dir), Path(self.vmtest_dir)
)
except vmtest.vm.LostVMError as e:
self.announce(f"error: {e}", log.ERROR)
return False
self.announce(f"Tests in VM returned {returncode}", log.INFO)
return returncode == 0
def run(self):
from pathlib import Path
from vmtest.download import KernelDownloader
# Start downloads ASAP so that they're hopefully done by the time we
# need them.
with KernelDownloader(self.kernels, Path(self.vmtest_dir)) as downloader:
if self.kernels:
self.announce("downloading kernels in the background", log.INFO)
self.run_command("egg_info")
self.reinitialize_command("build_ext", inplace=1)
self.run_command("build_ext")
passed = []
failed = []
if self.kernels:
self.announce("running tests locally", log.INFO)
if self._run_local():
passed.append("local")
else:
failed.append("local")
if self.kernels:
for kernel in downloader:
self.announce(
f"running tests in VM on Linux {kernel.name}", log.INFO
)
if self._run_vm(kernel):
passed.append(kernel.name)
else:
failed.append(kernel.name)
if passed:
self.announce(f'Passed: {", ".join(passed)}', log.INFO)
if failed:
self.announce(f'Failed: {", ".join(failed)}', log.ERROR)
if failed:
raise DistutilsError("some tests failed")
else:
self.announce("all tests passed", log.INFO)
def get_version():
try:
with open("drgn/internal/version.py", "r") as f:
version_py = f.read()
except FileNotFoundError:
version_py = None
# The public version always comes from configure.ac.
with open("libdrgn/configure.ac", "r") as f:
public_version = re.search(r"AC_INIT\(\[drgn\], \[([^]]*)\]", f.read()).group(1)
# Default local version if we fail.
local_version = "+unknown"
# If this is a git repository, use a git-describe(1)-esque local version.
# Otherwise, get the local version saved in the sdist.
if os.path.exists(".git"):
# Read the Docs modifies the working tree (namely, docs/conf.py). We
# don't want the documentation to display a dirty version, so ignore
# modifications for RTD builds.
dirty = os.getenv("READTHEDOCS") != "True" and bool(
subprocess.check_output(
["git", "status", "-uno", "--porcelain"],
# Use the environment variable instead of --no-optional-locks
# to support Git < 2.14.
env={**os.environ, "GIT_OPTIONAL_LOCKS": "0"},
)
)
try:
count = int(
subprocess.check_output(
["git", "rev-list", "--count", f"v{public_version}.."],
stderr=subprocess.DEVNULL,
universal_newlines=True,
)
)
except subprocess.CalledProcessError:
log.warn("warning: v%s tag not found", public_version)
else:
if count == 0:
local_version = "+dirty" if dirty else ""
else:
commit = subprocess.check_output(
["git", "rev-parse", "--short", "HEAD"], universal_newlines=True
).strip()
local_version = f"+{count}.g{commit}"
if dirty:
local_version += ".dirty"
else:
if version_py is None:
# This isn't a proper sdist (maybe a git archive).
log.warn("warning: drgn/internal/version.py not found")
else:
# The saved version must start with the public version.
match = re.search(
fr'^__version__ = "{re.escape(public_version)}([^"]*)"$',
version_py,
re.M,
)
if match:
local_version = match.group(1)
else:
log.warn("warning: drgn/internal/version.py is invalid")
version = public_version + local_version
# Update version.py if necessary.
new_version_py = f'__version__ = "{version}"\n'
if new_version_py != version_py:
with open("drgn/internal/version.py", "w") as f:
f.write(new_version_py)
return version
with open("README.rst", "r") as f:
long_description = f.read()
setup(
name="drgn",
version=get_version(),
packages=find_packages(include=["drgn", "drgn.*"]),
package_data={"drgn": ["../_drgn.pyi", "py.typed"]},
# This is here so that setuptools knows that we have an extension; it's
# actually built using autotools/make.
ext_modules=[Extension(name="_drgn", sources=[])],
cmdclass={
"build": build,
"build_ext": build_ext,
"egg_info": egg_info,
"test": test,
},
entry_points={"console_scripts": ["drgn=drgn.internal.cli:main"]},
python_requires=">=3.6",
author="Omar Sandoval",
author_email="osandov@osandov.com",
description="Scriptable debugger library",
long_description=long_description,
long_description_content_type="text/x-rst",
url="https://github.com/osandov/drgn",
project_urls={
"Bug Tracker": "https://github.com/osandov/drgn/issues",
"Documentation": "https://drgn.readthedocs.io",
},
license="GPL-3.0+",
classifiers=[
"Development Status :: 3 - Alpha",
"Environment :: Console",
"Intended Audience :: Developers",
"License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python :: 3",
"Topic :: Software Development :: Debuggers",
],
)