virt-manager/setup.py

699 lines
22 KiB
Python
Executable File

#!/usr/bin/env python3
#
# This work is licensed under the GNU GPLv2.
# See the COPYING file in the top-level directory.
import glob
import fnmatch
import os
import sys
import unittest
import distutils
import distutils.command.build
import distutils.command.install
import distutils.command.install_data
import distutils.command.install_egg_info
import distutils.command.sdist
import distutils.dist
import distutils.log
import distutils.sysconfig
from virtcli import CLIConfig
sysprefix = distutils.sysconfig.get_config_var("prefix")
if sys.version_info.major < 3:
print("virt-manager is python3 only. Run this as ./setup.py")
sys.exit(1)
# pylint: disable=attribute-defined-outside-init
_desktop_files = [
("share/applications", ["data/virt-manager.desktop.in"]),
]
_appdata_files = [
("share/appdata", ["data/virt-manager.appdata.xml.in"]),
]
def _generate_potfiles_in():
def find(dirname, ext):
ret = []
for root, ignore, filenames in os.walk(dirname):
for filename in fnmatch.filter(filenames, ext):
ret.append(os.path.join(root, filename))
ret.sort(key=lambda s: s.lower())
return ret
scripts = ["virt-manager", "virt-install",
"virt-clone", "virt-convert", "virt-xml"]
potfiles = "\n".join(scripts) + "\n\n"
potfiles += "\n".join(find("virtManager", "*.py")) + "\n\n"
potfiles += "\n".join(find("virtcli", "*.py")) + "\n\n"
potfiles += "\n".join(find("virtconv", "*.py")) + "\n\n"
potfiles += "\n".join(find("virtinst", "*.py")) + "\n\n"
for ignore, filelist in _desktop_files + _appdata_files:
potfiles += "\n".join(filelist) + "\n"
potfiles += "\n"
potfiles += "\n".join(["[type: gettext/glade]" + f for
f in find("ui", "*.ui")]) + "\n\n"
return potfiles
class my_build_i18n(distutils.command.build.build):
"""
Add our desktop files to the list, saves us having to track setup.cfg
"""
user_options = [
('merge-po', 'm', 'merge po files against template'),
]
def initialize_options(self):
self.merge_po = False
def finalize_options(self):
pass
def run(self):
potfiles = _generate_potfiles_in()
potpath = "po/POTFILES.in"
try:
print("Writing %s" % potpath)
open(potpath, "w").write(potfiles)
self._run()
finally:
print("Removing %s" % potpath)
os.unlink(potpath)
def _run(self):
# Borrowed from python-distutils-extra
po_dir = "po"
# Update po(t) files and print a report
# We have to change the working dir to the po dir for intltool
cmd = ["intltool-update",
(self.merge_po and "-r" or "-p"), "-g", "virt-manager"]
wd = os.getcwd()
os.chdir("po")
self.spawn(cmd)
os.chdir(wd)
max_po_mtime = 0
for po_file in glob.glob("%s/*.po" % po_dir):
lang = os.path.basename(po_file[:-3])
mo_dir = os.path.join("build", "mo", lang, "LC_MESSAGES")
mo_file = os.path.join(mo_dir, "virt-manager.mo")
if not os.path.exists(mo_dir):
os.makedirs(mo_dir)
cmd = ["msgfmt", po_file, "-o", mo_file]
po_mtime = os.path.getmtime(po_file)
mo_mtime = (os.path.exists(mo_file) and
os.path.getmtime(mo_file)) or 0
if po_mtime > max_po_mtime:
max_po_mtime = po_mtime
if po_mtime > mo_mtime:
self.spawn(cmd)
targetpath = os.path.join("share/locale", lang, "LC_MESSAGES")
self.distribution.data_files.append((targetpath, (mo_file,)))
# merge .in with translation
for (file_set, switch) in [(_desktop_files, "-d"),
(_appdata_files, "-x")]:
for (target, files) in file_set:
build_target = os.path.join("build", target)
if not os.path.exists(build_target):
os.makedirs(build_target)
files_merged = []
for f in files:
if f.endswith(".in"):
file_merged = os.path.basename(f[:-3])
else:
file_merged = os.path.basename(f)
file_merged = os.path.join(build_target, file_merged)
cmd = ["intltool-merge", switch, po_dir, f,
file_merged]
mtime_merged = (os.path.exists(file_merged) and
os.path.getmtime(file_merged)) or 0
mtime_file = os.path.getmtime(f)
if (mtime_merged < max_po_mtime or
mtime_merged < mtime_file):
# Only build if output is older than input (.po,.in)
self.spawn(cmd)
files_merged.append(file_merged)
self.distribution.data_files.append((target, files_merged))
class my_build(distutils.command.build.build):
"""
Create simple shell wrappers for /usr/bin/ tools to point to /usr/share
Compile .pod file
"""
def _make_bin_wrappers(self):
cmds = ["virt-manager", "virt-install", "virt-clone",
"virt-convert", "virt-xml"]
if not os.path.exists("build"):
os.mkdir("build")
for app in cmds:
sharepath = os.path.join(CLIConfig.prefix,
"share", "virt-manager", app)
wrapper = "#!/bin/sh\n\n"
wrapper += "exec \"%s\" \"$@\"" % (sharepath)
newpath = os.path.abspath(os.path.join("build", app))
print("Generating %s" % newpath)
open(newpath, "w").write(wrapper)
def _make_man_pages(self):
for path in glob.glob("man/*.pod"):
base = os.path.basename(path)
appname = os.path.splitext(base)[0]
newpath = os.path.join(os.path.dirname(path),
appname + ".1")
print("Generating %s" % newpath)
ret = os.system('pod2man '
'--center "Virtual Machine Manager" '
'--release %s --name %s '
'< %s > %s' % (CLIConfig.version,
appname.upper(),
path, newpath))
if ret != 0:
raise RuntimeError("Generating '%s' failed." % newpath)
if os.system("grep -IRq 'Hey!' man/") == 0:
raise RuntimeError("man pages have errors in them! "
"(grep for 'Hey!')")
def _build_icons(self):
for size in glob.glob(os.path.join("data/icons", "*")):
for category in glob.glob(os.path.join(size, "*")):
icons = []
for icon in glob.glob(os.path.join(category, "*")):
icons.append(icon)
if not icons:
continue
category = os.path.basename(category)
dest = ("share/icons/hicolor/%s/%s" %
(os.path.basename(size), category))
if category != "apps":
dest = dest.replace("share/", "share/virt-manager/")
self.distribution.data_files.append((dest, icons))
def run(self):
self._make_bin_wrappers()
self._make_man_pages()
self._build_icons()
self.run_command("build_i18n")
distutils.command.build.build.run(self)
class my_egg_info(distutils.command.install_egg_info.install_egg_info):
"""
Disable egg_info installation, seems pointless for a non-library
"""
def run(self):
pass
class my_install(distutils.command.install.install):
"""
Error if we weren't 'configure'd with the correct install prefix
"""
def finalize_options(self):
if self.prefix is None:
if CLIConfig.prefix != sysprefix:
print("Using configured prefix=%s instead of sysprefix=%s" % (
CLIConfig.prefix, sysprefix))
self.prefix = CLIConfig.prefix
else:
print("Using sysprefix=%s" % sysprefix)
self.prefix = sysprefix
elif self.prefix != CLIConfig.prefix:
print("Install prefix=%s doesn't match configure prefix=%s\n"
"Pass matching --prefix to 'setup.py configure'" %
(self.prefix, CLIConfig.prefix))
sys.exit(1)
distutils.command.install.install.finalize_options(self)
class my_install_data(distutils.command.install_data.install_data):
def run(self):
distutils.command.install_data.install_data.run(self)
if not self.distribution.no_update_icon_cache:
distutils.log.info("running gtk-update-icon-cache")
icon_path = os.path.join(self.install_dir, "share/icons/hicolor")
self.spawn(["gtk-update-icon-cache", "-q", "-t", icon_path])
if not self.distribution.no_compile_schemas:
distutils.log.info("compiling gsettings schemas")
gschema_install = os.path.join(self.install_dir,
"share/glib-2.0/schemas")
self.spawn(["glib-compile-schemas", gschema_install])
class my_sdist(distutils.command.sdist.sdist):
description = "Update virt-manager.spec; build sdist-tarball."
def run(self):
f1 = open('virt-manager.spec.in', 'r')
f2 = open('virt-manager.spec', 'w')
for line in f1:
f2.write(line.replace('@VERSION@', CLIConfig.version))
f1.close()
f2.close()
distutils.command.sdist.sdist.run(self)
###################
# Custom commands #
###################
class my_rpm(distutils.core.Command):
user_options = []
description = "Build src and noarch rpms."
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
"""
Run sdist, then 'rpmbuild' the tar.gz
"""
self.run_command('sdist')
os.system('rpmbuild -ta --clean dist/virt-manager-%s.tar.gz' %
CLIConfig.version)
class configure(distutils.core.Command):
user_options = [
("prefix=", None, "installation prefix"),
("qemu-user=", None,
"user libvirt uses to launch qemu processes (default=root)"),
("libvirt-package-names=", None,
"list of libvirt distro packages virt-manager will check for on "
"first run. comma separated string (default=none)"),
("kvm-package-names=", None,
"recommended kvm packages virt-manager will check for on first run "
"(default=none)"),
("askpass-package-names=", None,
"name of your distro's askpass package(s) (default=none)"),
("preferred-distros=", None,
"Distros to list first in the New VM wizard (default=none)"),
("stable-defaults", None,
"Hide config bits that are not considered stable (default=no)"),
("default-graphics=", None,
"Default graphics type (spice or vnc) (default=spice)"),
("default-hvs=", None,
"Comma separated list of hypervisors shown in 'Open Connection' "
"wizard. (default=all hvs)"),
]
description = "Configure the build, similar to ./configure"
def finalize_options(self):
pass
def initialize_options(self):
self.prefix = sysprefix
self.qemu_user = None
self.libvirt_package_names = None
self.kvm_package_names = None
self.askpass_package_names = None
self.preferred_distros = None
self.stable_defaults = None
self.default_graphics = None
self.default_hvs = None
def run(self):
template = ""
template += "[config]\n"
template += "prefix = %s\n" % self.prefix
if self.qemu_user is not None:
template += "default_qemu_user = %s\n" % self.qemu_user
if self.libvirt_package_names is not None:
template += "libvirt_packages = %s\n" % self.libvirt_package_names
if self.kvm_package_names is not None:
template += "hv_packages = %s\n" % self.kvm_package_names
if self.askpass_package_names is not None:
template += "askpass_packages = %s\n" % self.askpass_package_names
if self.preferred_distros is not None:
template += "preferred_distros = %s\n" % self.preferred_distros
if self.stable_defaults is not None:
template += ("stable_defaults = %s\n" %
self.stable_defaults)
if self.default_graphics is not None:
template += "default_graphics = %s\n" % self.default_graphics
if self.default_hvs is not None:
template += "default_hvs = %s\n" % self.default_hvs
open(CLIConfig.cfgpath, "w").write(template)
print("Generated %s" % CLIConfig.cfgpath)
class TestBaseCommand(distutils.core.Command):
user_options = [
('debug', 'd', 'Show debug output'),
('testverbose', None, 'Show verbose output'),
('coverage', 'c', 'Show coverage report'),
('regenerate-output', None, 'Regenerate test output'),
("only=", None,
"Run only testcases whose name contains the passed string"),
("testfile=", None, "Specific test file to run (e.g "
"validation, storage, ...)"),
]
def initialize_options(self):
self.debug = 0
self.testverbose = 0
self.regenerate_output = 0
self.coverage = 0
self.only = None
self._testfiles = []
self._dir = os.getcwd()
self.testfile = None
self._force_verbose = False
self._external_coverage = False
def finalize_options(self):
if self.only:
# Can do --only many-devices to match on the cli testcase
# for "virt-install-many-devices", despite the actual test
# function name not containing any '-'
self.only = self.only.replace("-", "_")
def _find_tests_in_dir(self, dirname, excludes):
testfiles = []
for t in sorted(glob.glob(os.path.join(self._dir, dirname, '*.py'))):
base = os.path.basename(t)
if base in excludes + ["__init__.py"]:
continue
if self.testfile:
check = os.path.basename(self.testfile)
if base != check and base != (check + ".py"):
continue
testfiles.append('.'.join(
dirname.split("/") + [os.path.splitext(base)[0]]))
if not testfiles:
raise RuntimeError("--testfile didn't catch anything")
return testfiles
def run(self):
cov = None
if self.coverage:
import coverage
omit = ["/usr/*", "/*/tests/*"]
cov = coverage.coverage(omit=omit)
cov.erase()
if not self._external_coverage:
cov.start()
import tests as testsmodule
testsmodule.utils.clistate.regenerate_output = bool(
self.regenerate_output)
testsmodule.utils.clistate.use_coverage = bool(cov)
testsmodule.utils.clistate.debug = bool(self.debug)
testsmodule.setup_logging()
testsmodule.setup_cli_imports()
# This makes the test runner report results before exiting from ctrl-c
unittest.installHandler()
tests = unittest.TestLoader().loadTestsFromNames(self._testfiles)
if self.only:
newtests = []
for suite1 in tests:
for suite2 in suite1:
for testcase in suite2:
if self.only in str(testcase):
newtests.append(testcase)
if not newtests:
print("--only didn't find any tests")
sys.exit(1)
tests = unittest.TestSuite(newtests)
print("Running only:")
for test in newtests:
print("%s" % test)
print("")
verbosity = 1
if self.debug or self.testverbose or self._force_verbose:
verbosity = 2
t = unittest.TextTestRunner(verbosity=verbosity)
try:
result = t.run(tests)
except KeyboardInterrupt:
sys.exit(1)
if cov:
if self._external_coverage:
cov.load()
else:
cov.stop()
cov.save()
err = int(bool(len(result.failures) > 0 or
len(result.errors) > 0))
if cov and not err:
cov.report(show_missing=False)
sys.exit(err)
class TestCommand(TestBaseCommand):
description = "Runs a quick unit test suite"
def initialize_options(self):
TestBaseCommand.initialize_options(self)
def finalize_options(self):
TestBaseCommand.finalize_options(self)
def run(self):
'''
Finds all the tests modules in tests/, and runs them.
'''
excludes = ["dist.py", "test_urls.py", "test_inject.py"]
testfiles = self._find_tests_in_dir("tests", excludes)
# Put clitest at the end, since it takes the longest
for f in testfiles[:]:
if "clitest" in f:
testfiles.remove(f)
testfiles.append(f)
# Always want to put checkprops at the end to get accurate results
for f in testfiles[:]:
if "checkprops" in f:
testfiles.remove(f)
if not self.testfile:
testfiles.append(f)
self._testfiles = testfiles
TestBaseCommand.run(self)
class TestUI(TestBaseCommand):
description = "Run UI dogtails tests"
def run(self):
self._testfiles = self._find_tests_in_dir("tests/uitests", [])
self._force_verbose = True
self._external_coverage = True
TestBaseCommand.run(self)
class TestURLFetch(TestBaseCommand):
description = "Test fetching kernels and isos from various distro trees"
def initialize_options(self):
TestBaseCommand.initialize_options(self)
self.path = ""
def finalize_options(self):
TestBaseCommand.finalize_options(self)
origpath = str(self.path)
if not origpath:
self.path = []
else:
self.path = origpath.split(",")
def run(self):
self._testfiles = ["tests.test_urls"]
TestBaseCommand.run(self)
class TestInitrdInject(TestBaseCommand):
description = "Test initrd inject with real kernels, fetched from URLs"
def run(self):
self._testfiles = ["tests.test_inject"]
TestBaseCommand.run(self)
class TestDist(TestBaseCommand):
description = "Tests to run before cutting a release"
def run(self):
self._testfiles = ["tests.dist"]
TestBaseCommand.run(self)
class CheckPylint(distutils.core.Command):
user_options = [
("jobs=", "j", "use multiple processes to speed up Pylint"),
]
description = "Check code using pylint and pycodestyle"
def initialize_options(self):
self.jobs = None
def finalize_options(self):
if self.jobs:
self.jobs = int(self.jobs)
def run(self):
import pylint.lint
import pycodestyle
files = ["setup.py", "virt-install", "virt-clone",
"virt-convert", "virt-xml", "virt-manager",
"virtcli", "virtinst", "virtconv", "virtManager",
"tests"]
output_format = sys.stdout.isatty() and "colorized" or "text"
exclude = ["virtinst/progress.py"]
print("running pycodestyle")
style_guide = pycodestyle.StyleGuide(
config_file='tests/pycodestyle.cfg',
paths=files
)
style_guide.options.exclude = pycodestyle.normalize_paths(
','.join(exclude)
)
report = style_guide.check_files()
if style_guide.options.count:
sys.stderr.write(str(report.total_errors) + '\n')
print("running pylint")
pylint_opts = [
"--rcfile", "tests/pylint.cfg",
"--output-format=%s" % output_format,
] + ["--ignore"] + [os.path.basename(p) for p in exclude]
if self.jobs:
pylint_opts += ["--jobs=%d" % self.jobs]
pylint.lint.Run(files + pylint_opts)
class VMMDistribution(distutils.dist.Distribution):
global_options = distutils.dist.Distribution.global_options + [
("no-update-icon-cache", None, "Don't run gtk-update-icon-cache"),
("no-compile-schemas", None, "Don't compile gsettings schemas"),
]
def __init__(self, *args, **kwargs):
self.no_update_icon_cache = False
self.no_compile_schemas = False
distutils.dist.Distribution.__init__(self, *args, **kwargs)
distutils.core.setup(
name="virt-manager",
version=CLIConfig.version,
author="Cole Robinson",
author_email="virt-tools-list@redhat.com",
url="http://virt-manager.org",
license="GPLv2+",
# These wrappers are generated in our custom build command
scripts=([
"build/virt-manager",
"build/virt-clone",
"build/virt-install",
"build/virt-convert",
"build/virt-xml"]),
data_files=[
("share/virt-manager/", [
"virt-manager",
"virt-install",
"virt-clone",
"virt-convert",
"virt-xml",
]),
("share/glib-2.0/schemas",
["data/org.virt-manager.virt-manager.gschema.xml"]),
("share/virt-manager/ui", glob.glob("ui/*.ui")),
("share/man/man1", [
"man/virt-manager.1",
"man/virt-install.1",
"man/virt-clone.1",
"man/virt-convert.1",
"man/virt-xml.1"
]),
("share/virt-manager/virtManager", glob.glob("virtManager/*.py")),
("share/virt-manager/virtcli",
glob.glob("virtcli/*.py") + glob.glob("virtcli/cli.cfg")),
("share/virt-manager/virtinst", glob.glob("virtinst/*.py")),
("share/virt-manager/virtconv", glob.glob("virtconv/*.py")),
],
cmdclass={
'build': my_build,
'build_i18n': my_build_i18n,
'sdist': my_sdist,
'install': my_install,
'install_data': my_install_data,
'install_egg_info': my_egg_info,
'configure': configure,
'pylint': CheckPylint,
'rpm': my_rpm,
'test': TestCommand,
'test_ui': TestUI,
'test_urls': TestURLFetch,
'test_initrd_inject': TestInitrdInject,
'test_dist': TestDist,
},
distclass=VMMDistribution,
)