diff options
| -rw-r--r-- | system/virt-manager/Add-Slackware-to-OS-choices.patch | 1388 | ||||
| -rw-r--r-- | system/virt-manager/virt-manager.SlackBuild | 11 | ||||
| -rw-r--r-- | system/virt-manager/virt-manager.info | 6 |
3 files changed, 14 insertions, 1391 deletions
diff --git a/system/virt-manager/Add-Slackware-to-OS-choices.patch b/system/virt-manager/Add-Slackware-to-OS-choices.patch index a4c1232739..18aadb62cf 100644 --- a/system/virt-manager/Add-Slackware-to-OS-choices.patch +++ b/system/virt-manager/Add-Slackware-to-OS-choices.patch @@ -1,6 +1,6 @@ -diff -Nur virt-manager-1.4.3.orig/virtinst/osdict.py virt-manager-1.4.3/virtinst/osdict.py ---- virt-manager-1.4.3.orig/virtinst/osdict.py 2017-08-16 16:32:14.000000000 -0500 -+++ virt-manager-1.4.3/virtinst/osdict.py 2017-10-03 01:02:59.322660395 -0500 +diff -Nur virt-manager-1.5.0.orig/virtinst/osdict.py virt-manager-1.5.0/virtinst/osdict.py +--- virt-manager-1.5.0.orig/virtinst/osdict.py 2018-01-27 14:57:20.000000000 -0600 ++++ virt-manager-1.5.0/virtinst/osdict.py 2018-02-19 00:52:00.750416744 -0600 @@ -159,6 +159,7 @@ "rhel5": "rhel5.0", "rhel6": "rhel6.0", @@ -18,10 +18,10 @@ diff -Nur virt-manager-1.4.3.orig/virtinst/osdict.py virt-manager-1.4.3/virtinst "ubuntu13.04", "win8", "win2k12", "mageia5", "centos7.0"], check_clones=False, check_derives=False): return True -diff -Nur virt-manager-1.4.3.orig/virtinst/urlfetcher.py virt-manager-1.4.3/virtinst/urlfetcher.py ---- virt-manager-1.4.3.orig/virtinst/urlfetcher.py 2017-09-14 16:49:00.000000000 -0500 -+++ virt-manager-1.4.3/virtinst/urlfetcher.py 2017-10-03 01:02:26.932287601 -0500 -@@ -1347,6 +1347,43 @@ +diff -Nur virt-manager-1.5.0.orig/virtinst/urlfetcher.py virt-manager-1.5.0/virtinst/urlfetcher.py +--- virt-manager-1.5.0.orig/virtinst/urlfetcher.py 2018-01-27 14:57:20.000000000 -0600 ++++ virt-manager-1.5.0/virtinst/urlfetcher.py 2018-02-19 00:52:00.751416752 -0600 +@@ -1379,6 +1379,43 @@ return False @@ -65,1377 +65,3 @@ diff -Nur virt-manager-1.4.3.orig/virtinst/urlfetcher.py virt-manager-1.4.3/virt # Build list of all *Distro classes def _build_distro_list(): allstores = [] -diff -Nur virt-manager-1.4.3.orig/virtinst/urlfetcher.py.orig virt-manager-1.4.3/virtinst/urlfetcher.py.orig ---- virt-manager-1.4.3.orig/virtinst/urlfetcher.py.orig 1969-12-31 18:00:00.000000000 -0600 -+++ virt-manager-1.4.3/virtinst/urlfetcher.py.orig 2017-09-14 16:49:00.000000000 -0500 -@@ -0,0 +1,1370 @@ -+# -+# Represents OS distribution specific install data -+# -+# Copyright 2006-2007, 2013 Red Hat, Inc. -+# Daniel P. Berrange <berrange@redhat.com> -+# -+# This program is free software; you can redistribute it and/or modify -+# it under the terms of the GNU General Public License as published by -+# the Free Software Foundation; either version 2 of the License, or -+# (at your option) any later version. -+# -+# This program is distributed in the hope that it will be useful, -+# but WITHOUT ANY WARRANTY; without even the implied warranty of -+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -+# GNU General Public License for more details. -+# -+# You should have received a copy of the GNU General Public License -+# along with this program; if not, write to the Free Software -+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, -+# MA 02110-1301 USA. -+ -+import ConfigParser -+import ftplib -+import logging -+import os -+import re -+import stat -+import StringIO -+import subprocess -+import tempfile -+import urllib2 -+import urlparse -+ -+import requests -+ -+from .osdict import OSDB -+ -+ -+######################################################################### -+# Backends for the various URL types we support (http, ftp, nfs, local) # -+######################################################################### -+ -+class _URLFetcher(object): -+ """ -+ This is a generic base class for fetching/extracting files from -+ a media source, such as CD ISO, NFS server, or HTTP/FTP server -+ """ -+ _block_size = 16384 -+ -+ def __init__(self, location, scratchdir, meter): -+ self.location = location -+ self.scratchdir = scratchdir -+ self.meter = meter -+ -+ self._srcdir = None -+ -+ logging.debug("Using scratchdir=%s", scratchdir) -+ -+ -+ #################### -+ # Internal helpers # -+ #################### -+ -+ def _make_full_url(self, filename): -+ """ -+ Generate a full fetchable URL from the passed filename, which -+ is relative to the self.location -+ """ -+ ret = self._srcdir or self.location -+ if not filename: -+ return ret -+ -+ if not ret.endswith("/"): -+ ret += "/" -+ return ret + filename -+ -+ def _grabURL(self, filename, fileobj): -+ """ -+ Download the filename from self.location, and write contents to -+ fileobj -+ """ -+ url = self._make_full_url(filename) -+ -+ try: -+ urlobj, size = self._grabber(url) -+ except Exception as e: -+ raise ValueError(_("Couldn't acquire file %s: %s") % -+ (url, str(e))) -+ -+ logging.debug("Fetching URI: %s", url) -+ self.meter.start( -+ text=_("Retrieving file %s...") % os.path.basename(filename), -+ size=size) -+ -+ total = self._write(urlobj, fileobj) -+ self.meter.end(total) -+ -+ def _write(self, urlobj, fileobj): -+ """ -+ Write the contents of urlobj to python file like object fileobj -+ """ -+ total = 0 -+ while 1: -+ buff = urlobj.read(self._block_size) -+ if not buff: -+ break -+ fileobj.write(buff) -+ total += len(buff) -+ self.meter.update(total) -+ return total -+ -+ def _grabber(self, url): -+ """ -+ Returns the urlobj, size for the passed URL. urlobj is whatever -+ data needs to be passed to self._write -+ """ -+ raise NotImplementedError("must be implemented in subclass") -+ -+ -+ ############## -+ # Public API # -+ ############## -+ -+ def prepareLocation(self): -+ """ -+ Perform any necessary setup -+ """ -+ pass -+ -+ def cleanupLocation(self): -+ """ -+ Perform any necessary cleanup -+ """ -+ pass -+ -+ def _hasFile(self, url): -+ raise NotImplementedError("Must be implemented in subclass") -+ -+ def hasFile(self, filename): -+ """ -+ Return True if self.location has the passed filename -+ """ -+ url = self._make_full_url(filename) -+ ret = self._hasFile(url) -+ logging.debug("hasFile(%s) returning %s", url, ret) -+ return ret -+ -+ def acquireFile(self, filename): -+ """ -+ Grab the passed filename from self.location and save it to -+ a temporary file, returning the temp filename -+ """ -+ prefix = "virtinst-" + os.path.basename(filename) + "." -+ -+ # pylint: disable=redefined-variable-type -+ if "VIRTINST_TEST_SUITE" in os.environ: -+ fn = os.path.join("/tmp", prefix) -+ fileobj = open(fn, "w") -+ else: -+ fileobj = tempfile.NamedTemporaryFile( -+ dir=self.scratchdir, prefix=prefix, delete=False) -+ fn = fileobj.name -+ -+ self._grabURL(filename, fileobj) -+ logging.debug("Saved file to " + fn) -+ return fn -+ -+ def acquireFileContent(self, filename): -+ """ -+ Grab the passed filename from self.location and return it as a string -+ """ -+ fileobj = StringIO.StringIO() -+ self._grabURL(filename, fileobj) -+ return fileobj.getvalue() -+ -+ -+class _HTTPURLFetcher(_URLFetcher): -+ def _hasFile(self, url): -+ """ -+ We just do a HEAD request to see if the file exists -+ """ -+ try: -+ response = requests.head(url, allow_redirects=True) -+ response.raise_for_status() -+ except Exception as e: -+ logging.debug("HTTP hasFile request failed: %s", str(e)) -+ return False -+ return True -+ -+ def _grabber(self, url): -+ """ -+ Use requests for this -+ """ -+ response = requests.get(url, stream=True) -+ response.raise_for_status() -+ try: -+ size = int(response.headers.get('content-length')) -+ except Exception: -+ size = None -+ return response, size -+ -+ def _write(self, urlobj, fileobj): -+ """ -+ The requests object doesn't have a file-like read() option, so -+ we need to implemente it ourselves -+ """ -+ total = 0 -+ for data in urlobj.iter_content(chunk_size=self._block_size): -+ fileobj.write(data) -+ total += len(data) -+ self.meter.update(total) -+ return total -+ -+ -+class _FTPURLFetcher(_URLFetcher): -+ _ftp = None -+ -+ def prepareLocation(self): -+ if self._ftp: -+ return -+ -+ try: -+ parsed = urlparse.urlparse(self.location) -+ self._ftp = ftplib.FTP() -+ self._ftp.connect(parsed.hostname, parsed.port) -+ self._ftp.login() -+ # Force binary mode -+ self._ftp.voidcmd("TYPE I") -+ except Exception as e: -+ raise ValueError(_("Opening URL %s failed: %s.") % -+ (self.location, str(e))) -+ -+ def _grabber(self, url): -+ """ -+ Use urllib2 and ftplib to grab the file -+ """ -+ request = urllib2.Request(url) -+ urlobj = urllib2.urlopen(request) -+ size = self._ftp.size(urlparse.urlparse(url)[2]) -+ return urlobj, size -+ -+ -+ def cleanupLocation(self): -+ if not self._ftp: -+ return -+ -+ try: -+ self._ftp.quit() -+ except Exception: -+ logging.debug("Error quitting ftp connection", exc_info=True) -+ -+ self._ftp = None -+ -+ def _hasFile(self, url): -+ path = urlparse.urlparse(url)[2] -+ -+ try: -+ try: -+ # If it's a file -+ self._ftp.size(path) -+ except ftplib.all_errors: -+ # If it's a dir -+ self._ftp.cwd(path) -+ except ftplib.all_errors as e: -+ logging.debug("FTP hasFile: couldn't access %s: %s", -+ url, str(e)) -+ return False -+ -+ return True -+ -+ -+class _LocalURLFetcher(_URLFetcher): -+ """ -+ For grabbing files from a local directory -+ """ -+ def _hasFile(self, url): -+ return os.path.exists(url) -+ -+ def _grabber(self, url): -+ urlobj = open(url, "r") -+ size = os.path.getsize(url) -+ return urlobj, size -+ -+ -+class _MountedURLFetcher(_LocalURLFetcher): -+ """ -+ Fetcher capable of extracting files from a NFS server -+ or loopback mounted file, or local CDROM device -+ """ -+ _in_test_suite = bool("VIRTINST_TEST_SUITE" in os.environ) -+ _mounted = False -+ -+ def prepareLocation(self): -+ if self._mounted: -+ return -+ -+ if self._in_test_suite: -+ self._srcdir = os.environ["VIRTINST_TEST_URL_DIR"] -+ else: -+ self._srcdir = tempfile.mkdtemp(prefix="virtinstmnt.", -+ dir=self.scratchdir) -+ mountcmd = "/bin/mount" -+ -+ logging.debug("Preparing mount at " + self._srcdir) -+ if self.location.startswith("nfs:"): -+ cmd = [mountcmd, "-o", "ro", self.location[4:], self._srcdir] -+ else: -+ if stat.S_ISBLK(os.stat(self.location)[stat.ST_MODE]): -+ mountopt = "ro" -+ else: -+ mountopt = "ro,loop" -+ cmd = [mountcmd, "-o", mountopt, self.location, self._srcdir] -+ -+ logging.debug("mount cmd: %s", cmd) -+ if not self._in_test_suite: -+ ret = subprocess.call(cmd) -+ if ret != 0: -+ self.cleanupLocation() -+ raise ValueError(_("Mounting location '%s' failed") % -+ (self.location)) -+ -+ self._mounted = True -+ -+ def cleanupLocation(self): -+ if not self._mounted: -+ return -+ -+ logging.debug("Cleaning up mount at " + self._srcdir) -+ try: -+ if not self._in_test_suite: -+ cmd = ["/bin/umount", self._srcdir] -+ subprocess.call(cmd) -+ try: -+ os.rmdir(self._srcdir) -+ except Exception: -+ pass -+ finally: -+ self._mounted = False -+ -+ -+def fetcherForURI(uri, *args, **kwargs): -+ if uri.startswith("http://") or uri.startswith("https://"): -+ fclass = _HTTPURLFetcher -+ elif uri.startswith("ftp://"): -+ fclass = _FTPURLFetcher -+ elif uri.startswith("nfs:"): -+ fclass = _MountedURLFetcher -+ elif os.path.isdir(uri): -+ # Pointing to a local tree -+ fclass = _LocalURLFetcher -+ else: -+ # Pointing to a path, like an .iso to mount -+ fclass = _MountedURLFetcher -+ return fclass(uri, *args, **kwargs) -+ -+ -+############################################### -+# Helpers for detecting distro from given URL # -+############################################### -+ -+def _grabTreeinfo(fetcher): -+ """ -+ See if the URL has treeinfo, and if so return it as a ConfigParser -+ object. -+ """ -+ try: -+ tmptreeinfo = fetcher.acquireFile(".treeinfo") -+ except ValueError: -+ return None -+ -+ try: -+ treeinfo = ConfigParser.SafeConfigParser() -+ treeinfo.read(tmptreeinfo) -+ finally: -+ os.unlink(tmptreeinfo) -+ -+ try: -+ treeinfo.get("general", "family") -+ except ConfigParser.NoSectionError: -+ logging.debug("Did not find 'family' section in treeinfo") -+ return None -+ -+ logging.debug("treeinfo family=%s", treeinfo.get("general", "family")) -+ return treeinfo -+ -+ -+def _distroFromSUSEContent(fetcher, arch, vmtype=None): -+ # Parse content file for the 'LABEL' field containing the distribution name -+ # None if no content, GenericDistro if unknown label type. -+ try: -+ cbuf = fetcher.acquireFileContent("content") -+ except ValueError: -+ return None -+ -+ distribution = None -+ distro_version = None -+ distro_summary = None -+ distro_distro = None -+ distro_arch = None -+ -+ lines = cbuf.splitlines()[1:] -+ for line in lines: -+ if line.startswith("LABEL "): -+ distribution = line.split(' ', 1) -+ elif line.startswith("DISTRO "): -+ distro_distro = line.rsplit(',', 1) -+ elif line.startswith("VERSION "): -+ distro_version = line.split(' ', 1) -+ if len(distro_version) > 1: -+ d_version = distro_version[1].split('-', 1) -+ if len(d_version) > 1: -+ distro_version[1] = d_version[0] -+ elif line.startswith("SUMMARY "): -+ distro_summary = line.split(' ', 1) -+ elif line.startswith("BASEARCHS "): -+ distro_arch = line.split(' ', 1) -+ elif line.startswith("DEFAULTBASE "): -+ distro_arch = line.split(' ', 1) -+ elif line.startswith("REPOID "): -+ distro_arch = line.rsplit('/', 1) -+ if distribution and distro_version and distro_arch: -+ break -+ -+ if not distribution: -+ if distro_summary: -+ distribution = distro_summary -+ elif distro_distro: -+ distribution = distro_distro -+ if distro_arch: -+ arch = distro_arch[1].strip() -+ # Fix for 13.2 official oss repo -+ if arch.find("i586-x86_64") != -1: -+ arch = "x86_64" -+ else: -+ if cbuf.find("x86_64") != -1: -+ arch = "x86_64" -+ elif cbuf.find("i586") != -1: -+ arch = "i586" -+ elif cbuf.find("s390x") != -1: -+ arch = "s390x" -+ -+ def _parse_sle_distribution(d): -+ sle_version = d[1].strip().rsplit(' ')[4] -+ if len(d[1].strip().rsplit(' ')) > 5: -+ sle_version = sle_version + '.' + d[1].strip().rsplit(' ')[5][2] -+ return ['VERSION', sle_version] -+ -+ dclass = GenericDistro -+ if distribution: -+ if re.match(".*SUSE Linux Enterprise Server*", distribution[1]) or \ -+ re.match(".*SUSE SLES*", distribution[1]): -+ dclass = SLESDistro -+ if distro_version is None: -+ distro_version = _parse_sle_distribution(distribution) -+ elif re.match(".*SUSE Linux Enterprise Desktop*", distribution[1]): -+ dclass = SLEDDistro -+ if distro_version is None: -+ distro_version = _parse_sle_distribution(distribution) -+ elif re.match(".*openSUSE.*", distribution[1]): -+ dclass = OpensuseDistro -+ if distro_version is None: -+ distro_version = ['VERSION', distribution[0].strip().rsplit(':')[4]] -+ -+ if distro_version is None: -+ return None -+ -+ ob = dclass(fetcher, arch, vmtype) -+ if dclass != GenericDistro: -+ ob.version_from_content = distro_version -+ -+ # Explictly call this, so we populate os_type/variant info -+ ob.isValidStore() -+ -+ return ob -+ -+ -+def getDistroStore(guest, fetcher): -+ stores = [] -+ logging.debug("Finding distro store for location=%s", fetcher.location) -+ -+ arch = guest.os.arch -+ _type = guest.os.os_type -+ urldistro = OSDB.lookup_os(guest.os_variant).urldistro -+ -+ treeinfo = _grabTreeinfo(fetcher) -+ if not treeinfo: -+ dist = _distroFromSUSEContent(fetcher, arch, _type) -+ if dist: -+ return dist -+ -+ stores = _allstores[:] -+ -+ # If user manually specified an os_distro, bump it's URL class -+ # to the top of the list -+ if urldistro: -+ logging.debug("variant=%s has distro=%s, looking for matching " -+ "distro store to prioritize", -+ guest.os_variant, urldistro) -+ found_store = None -+ for store in stores: -+ if store.urldistro == urldistro: -+ found_store = store -+ -+ if found_store: -+ logging.debug("Prioritizing distro store=%s", found_store) -+ stores.remove(found_store) -+ stores.insert(0, found_store) -+ else: -+ logging.debug("No matching store found, not prioritizing anything") -+ -+ if treeinfo: -+ stores.sort(key=lambda x: not x.uses_treeinfo) -+ -+ for sclass in stores: -+ store = sclass(fetcher, arch, _type) -+ store.treeinfo = treeinfo -+ if store.isValidStore(): -+ logging.debug("Detected distro name=%s osvariant=%s", -+ store.name, store.os_variant) -+ return store -+ -+ # No distro was detected. See if the URL even resolves, and if not -+ # give the user a hint that maybe they mistyped. This won't always -+ # be true since some webservers don't allow directory listing. -+ # http://www.redhat.com/archives/virt-tools-list/2014-December/msg00048.html -+ extramsg = "" -+ if not fetcher.hasFile(""): -+ extramsg = (": " + -+ _("The URL could not be accessed, maybe you mistyped?")) -+ -+ raise ValueError( -+ _("Could not find an installable distribution at '%s'%s\n\n" -+ "The location must be the root directory of an install tree.\n" -+ "See virt-install man page for various distro examples." % -+ (fetcher.location, extramsg))) -+ -+ -+################## -+# Distro classes # -+################## -+ -+class Distro(object): -+ """ -+ An image store is a base class for retrieving either a bootable -+ ISO image, or a kernel+initrd pair for a particular OS distribution -+ """ -+ name = None -+ urldistro = None -+ uses_treeinfo = False -+ -+ # osdict variant value -+ os_variant = None -+ -+ _boot_iso_paths = [] -+ _hvm_kernel_paths = [] -+ _xen_kernel_paths = [] -+ version_from_content = [] -+ -+ def __init__(self, fetcher, arch, vmtype): -+ self.fetcher = fetcher -+ self.type = vmtype -+ self.arch = arch -+ -+ self.uri = fetcher.location -+ -+ # This is set externally -+ self.treeinfo = None -+ -+ def isValidStore(self): -+ """Determine if uri points to a tree of the store's distro""" -+ raise NotImplementedError -+ -+ def acquireKernel(self, guest): -+ kernelpath = None -+ initrdpath = None -+ if self.treeinfo: -+ try: -+ kernelpath = self._getTreeinfoMedia("kernel") -+ initrdpath = self._getTreeinfoMedia("initrd") -+ except ConfigParser.NoSectionError: -+ pass -+ -+ if not kernelpath or not initrdpath: -+ # fall back to old code -+ if self.type is None or self.type == "hvm": -+ paths = self._hvm_kernel_paths -+ else: -+ paths = self._xen_kernel_paths -+ -+ for kpath, ipath in paths: -+ if self.fetcher.hasFile(kpath) and self.fetcher.hasFile(ipath): -+ kernelpath = kpath -+ initrdpath = ipath -+ -+ if not kernelpath or not initrdpath: -+ raise RuntimeError(_("Couldn't find %(type)s kernel for " -+ "%(distro)s tree.") % -+ {"distro": self.name, "type": self.type}) -+ -+ return self._kernelFetchHelper(guest, kernelpath, initrdpath) -+ -+ def acquireBootDisk(self, guest): -+ ignore = guest -+ -+ if self.treeinfo: -+ return self.fetcher.acquireFile(self._getTreeinfoMedia("boot.iso")) -+ -+ for path in self._boot_iso_paths: -+ if self.fetcher.hasFile(path): -+ return self.fetcher.acquireFile(path) -+ raise RuntimeError(_("Could not find boot.iso in %s tree." % -+ self.name)) -+ -+ def _check_osvariant_valid(self, os_variant): -+ return OSDB.lookup_os(os_variant) is not None -+ -+ def get_osdict_info(self): -+ """ -+ Return (distro, variant) tuple, checking to make sure they are valid -+ osdict entries -+ """ -+ if not self.os_variant: -+ return None -+ -+ if not self._check_osvariant_valid(self.os_variant): -+ logging.debug("%s set os_variant to %s, which is not in osdict.", -+ self, self.os_variant) -+ return None -+ -+ return self.os_variant -+ -+ def _get_method_arg(self): -+ return "method" -+ -+ def _getTreeinfoMedia(self, mediaName): -+ if self.type == "xen": -+ t = "xen" -+ else: -+ t = self.treeinfo.get("general", "arch") -+ -+ return self.treeinfo.get("images-%s" % t, mediaName) -+ -+ def _fetchAndMatchRegex(self, filename, regex): -+ # Fetch 'filename' and return True/False if it matches the regex -+ try: -+ content = self.fetcher.acquireFileContent(filename) -+ except ValueError: -+ return False -+ -+ for line in content.splitlines(): -+ if re.match(regex, line): -+ return True -+ -+ return False -+ -+ def _kernelFetchHelper(self, guest, kernelpath, initrdpath): -+ # Simple helper for fetching kernel + initrd and performing -+ # cleanup if necessary -+ ignore = guest -+ kernel = self.fetcher.acquireFile(kernelpath) -+ args = '' -+ -+ if not self.fetcher.location.startswith("/"): -+ args += "%s=%s" % (self._get_method_arg(), self.fetcher.location) -+ -+ try: -+ initrd = self.fetcher.acquireFile(initrdpath) -+ return kernel, initrd, args -+ except Exception: -+ os.unlink(kernel) -+ raise -+ -+ -+class GenericDistro(Distro): -+ """ -+ Generic distro store. Check well known paths for kernel locations -+ as a last resort if we can't recognize any actual distro -+ """ -+ name = "Generic" -+ uses_treeinfo = True -+ -+ _xen_paths = [("images/xen/vmlinuz", -+ "images/xen/initrd.img"), # Fedora -+ ] -+ _hvm_paths = [("images/pxeboot/vmlinuz", -+ "images/pxeboot/initrd.img"), # Fedora -+ ("ppc/ppc64/vmlinuz", -+ "ppc/ppc64/initrd.img"), # CenOS 7 ppc64le -+ ] -+ _iso_paths = ["images/boot.iso", # RH/Fedora -+ "boot/boot.iso", # Suse -+ "current/images/netboot/mini.iso", # Debian -+ "install/images/boot.iso", # Mandriva -+ ] -+ -+ # Holds values to use when actually pulling down media -+ _valid_kernel_path = None -+ _valid_iso_path = None -+ -+ def isValidStore(self): -+ if self.treeinfo: -+ # Use treeinfo to pull down media paths -+ if self.type == "xen": -+ typ = "xen" -+ else: -+ typ = self.treeinfo.get("general", "arch") -+ -+ kernelSection = "images-%s" % typ -+ isoSection = "images-%s" % self.treeinfo.get("general", "arch") -+ -+ if self.treeinfo.has_section(kernelSection): -+ try: -+ self._valid_kernel_path = ( -+ self._getTreeinfoMedia("kernel"), -+ self._getTreeinfoMedia("initrd")) -+ except (ConfigParser.NoSectionError, -+ ConfigParser.NoOptionError) as e: -+ logging.debug(e) -+ -+ if self.treeinfo.has_section(isoSection): -+ try: -+ self._valid_iso_path = self.treeinfo.get(isoSection, -+ "boot.iso") -+ except ConfigParser.NoOptionError as e: -+ logging.debug(e) -+ -+ if self.type == "xen": -+ kern_list = self._xen_paths -+ else: -+ kern_list = self._hvm_paths -+ -+ # If validated media paths weren't found (no treeinfo), check against -+ # list of media location paths. -+ for kern, init in kern_list: -+ if (self._valid_kernel_path is None and -+ self.fetcher.hasFile(kern) and -+ self.fetcher.hasFile(init)): -+ self._valid_kernel_path = (kern, init) -+ break -+ -+ for iso in self._iso_paths: -+ if (self._valid_iso_path is None and -+ self.fetcher.hasFile(iso)): -+ self._valid_iso_path = iso -+ break -+ -+ if self._valid_kernel_path or self._valid_iso_path: -+ return True -+ return False -+ -+ def acquireKernel(self, guest): -+ if self._valid_kernel_path is None: -+ raise ValueError(_("Could not find a kernel path for virt type " -+ "'%s'" % self.type)) -+ -+ return self._kernelFetchHelper(guest, -+ self._valid_kernel_path[0], -+ self._valid_kernel_path[1]) -+ -+ def acquireBootDisk(self, guest): -+ if self._valid_iso_path is None: -+ raise ValueError(_("Could not find a boot iso path for this tree.")) -+ -+ return self.fetcher.acquireFile(self._valid_iso_path) -+ -+ -+class RedHatDistro(Distro): -+ """ -+ Base image store for any Red Hat related distros which have -+ a common layout -+ """ -+ uses_treeinfo = True -+ _version_number = None -+ -+ _boot_iso_paths = ["images/boot.iso"] -+ _hvm_kernel_paths = [("images/pxeboot/vmlinuz", -+ "images/pxeboot/initrd.img")] -+ _xen_kernel_paths = [("images/xen/vmlinuz", -+ "images/xen/initrd.img")] -+ -+ def isValidStore(self): -+ raise NotImplementedError() -+ -+ def _get_method_arg(self): -+ if (self._version_number is not None and -+ ((self.urldistro == "rhel" and self._version_number >= 7) or -+ (self.urldistro == "fedora" and self._version_number >= 19))): -+ return "inst.repo" -+ return "method" -+ -+ -+# Fedora distro check -+class FedoraDistro(RedHatDistro): -+ name = "Fedora" -+ urldistro = "fedora" -+ -+ def isValidStore(self): -+ if not self.treeinfo: -+ return self.fetcher.hasFile("Fedora") -+ -+ if not re.match(".*Fedora.*", self.treeinfo.get("general", "family")): -+ return False -+ -+ ver = self.treeinfo.get("general", "version") -+ if not ver: -+ logging.debug("No version found in .treeinfo") -+ return False -+ logging.debug("Found treeinfo version=%s", ver) -+ -+ latest_variant = OSDB.latest_fedora_version() -+ if re.match("fedora[0-9]+", latest_variant): -+ latest_vernum = int(latest_variant[6:]) -+ else: -+ logging.debug("Failed to parse version number from latest " -+ "fedora variant=%s. Using safe default 22", latest_variant) -+ latest_vernum = 22 -+ -+ # rawhide trees changed to use version=Rawhide in Apr 2016 -+ if ver in ["development", "rawhide", "Rawhide"]: -+ self._version_number = latest_vernum -+ self.os_variant = latest_variant -+ return True -+ -+ # Dev versions can be like '23_Alpha' -+ if "_" in ver: -+ ver = ver.split("_")[0] -+ -+ # Typical versions are like 'fedora-23' -+ vernum = str(ver).split("-")[0] -+ if vernum.isdigit(): -+ vernum = int(vernum) -+ else: -+ logging.debug("Failed to parse version number from treeinfo " -+ "version=%s, using vernum=latest=%s", ver, latest_vernum) -+ vernum = latest_vernum -+ -+ if vernum > latest_vernum: -+ self.os_variant = latest_variant -+ else: -+ self.os_variant = "fedora" + str(vernum) -+ -+ self._version_number = vernum -+ return True -+ -+ -+# Red Hat Enterprise Linux distro check -+class RHELDistro(RedHatDistro): -+ name = "Red Hat Enterprise Linux" -+ urldistro = "rhel" -+ -+ def isValidStore(self): -+ if self.treeinfo: -+ # Matches: -+ # Red Hat Enterprise Linux -+ # RHEL Atomic Host -+ m = re.match(".*(Red Hat Enterprise Linux|RHEL).*", -+ self.treeinfo.get("general", "family")) -+ ret = (m is not None) -+ -+ if ret: -+ self._variantFromVersion() -+ return ret -+ -+ if (self.fetcher.hasFile("Server") or -+ self.fetcher.hasFile("Client")): -+ self.os_variant = "rhel5" -+ return True -+ return self.fetcher.hasFile("RedHat") -+ -+ -+ ################################ -+ # osdict autodetection helpers # -+ ################################ -+ -+ def _parseTreeinfoVersion(self, verstr): -+ def _safeint(c): -+ try: -+ val = int(c) -+ except Exception: -+ val = 0 -+ return val -+ -+ version = _safeint(verstr[0]) -+ update = 0 -+ -+ # RHEL has version=5.4, scientific linux=54 -+ updinfo = verstr.split(".") -+ if len(updinfo) > 1: -+ update = _safeint(updinfo[1]) -+ elif len(verstr) > 1: -+ update = _safeint(verstr[1]) -+ -+ return version, update -+ -+ def _variantFromVersion(self): -+ ver = self.treeinfo.get("general", "version") -+ name = None -+ if self.treeinfo.has_option("general", "name"): -+ name = self.treeinfo.get("general", "name") -+ if not ver: -+ return -+ -+ if name and name.startswith("Red Hat Enterprise Linux Server for ARM"): -+ # Kind of a hack, but good enough for the time being -+ version = 7 -+ update = 0 -+ else: -+ version, update = self._parseTreeinfoVersion(ver) -+ -+ self._version_number = version -+ self._setRHELVariant(version, update) -+ -+ def _setRHELVariant(self, version, update): -+ base = "rhel" + str(version) -+ if update < 0: -+ update = 0 -+ -+ ret = None -+ while update >= 0: -+ tryvar = base + ".%s" % update -+ if not self._check_osvariant_valid(tryvar): -+ update -= 1 -+ continue -+ -+ ret = tryvar -+ break -+ -+ if not ret: -+ # Try plain rhel5, rhel6, whatev -+ if self._check_osvariant_valid(base): -+ ret = base -+ -+ if ret: -+ self.os_variant = ret -+ -+ -+# CentOS distro check -+class CentOSDistro(RHELDistro): -+ name = "CentOS" -+ urldistro = "centos" -+ -+ def isValidStore(self): -+ if not self.treeinfo: -+ return self.fetcher.hasFile("CentOS") -+ -+ m = re.match(".*CentOS.*", self.treeinfo.get("general", "family")) -+ ret = (m is not None) -+ if ret: -+ self._variantFromVersion() -+ if self.os_variant: -+ new_variant = self.os_variant.replace("rhel", "centos") -+ if self._check_osvariant_valid(new_variant): -+ self.os_variant = new_variant -+ return ret -+ -+ -+# Scientific Linux distro check -+class SLDistro(RHELDistro): -+ name = "Scientific Linux" -+ urldistro = None -+ -+ _boot_iso_paths = RHELDistro._boot_iso_paths + ["images/SL/boot.iso"] -+ _hvm_kernel_paths = RHELDistro._hvm_kernel_paths + [ -+ ("images/SL/pxeboot/vmlinuz", "images/SL/pxeboot/initrd.img")] -+ -+ def isValidStore(self): -+ if self.treeinfo: -+ m = re.match(".*Scientific.*", -+ self.treeinfo.get("general", "family")) -+ ret = (m is not None) -+ -+ if ret: -+ self._variantFromVersion() -+ return ret -+ -+ return self.fetcher.hasFile("SL") -+ -+ -+class SuseDistro(Distro): -+ name = "SUSE" -+ -+ _boot_iso_paths = ["boot/boot.iso"] -+ -+ def __init__(self, *args, **kwargs): -+ Distro.__init__(self, *args, **kwargs) -+ if re.match(r'i[4-9]86', self.arch): -+ self.arch = 'i386' -+ -+ oldkern = "linux" -+ oldinit = "initrd" -+ if self.arch == "x86_64": -+ oldkern += "64" -+ oldinit += "64" -+ -+ if self.arch == "s390x": -+ self._hvm_kernel_paths = [("boot/%s/linux" % self.arch, -+ "boot/%s/initrd" % self.arch)] -+ # No Xen on s390x -+ self._xen_kernel_paths = [] -+ else: -+ # Tested with Opensuse >= 10.2, 11, and sles 10 -+ self._hvm_kernel_paths = [("boot/%s/loader/linux" % self.arch, -+ "boot/%s/loader/initrd" % self.arch)] -+ # Tested with Opensuse 10.0 -+ self._hvm_kernel_paths.append(("boot/loader/%s" % oldkern, -+ "boot/loader/%s" % oldinit)) -+ # Tested with SLES 12 for ppc64le -+ self._hvm_kernel_paths.append(("boot/%s/linux" % self.arch, -+ "boot/%s/initrd" % self.arch)) -+ -+ # Matches Opensuse > 10.2 and sles 10 -+ self._xen_kernel_paths = [("boot/%s/vmlinuz-xen" % self.arch, -+ "boot/%s/initrd-xen" % self.arch)] -+ -+ def _variantFromVersion(self): -+ distro_version = self.version_from_content[1].strip() -+ version = distro_version.split('.', 1)[0].strip() -+ self.os_variant = self.urldistro -+ if int(version) >= 10: -+ if self.os_variant.startswith(("sles", "sled")): -+ sp_version = None -+ if len(distro_version.split('.', 1)) == 2: -+ sp_version = 'sp' + distro_version.split('.', 1)[1].strip() -+ self.os_variant += version -+ if sp_version: -+ self.os_variant += sp_version -+ else: -+ # Tumbleweed 8 digit date -+ if len(version) == 8: -+ self.os_variant += "tumbleweed" -+ else: -+ self.os_variant += distro_version -+ else: -+ self.os_variant += "9" -+ -+ def isValidStore(self): -+ # self.version_from_content is the VERSION line from the contents file -+ if (not self.version_from_content or -+ self.version_from_content[1] is None): -+ return False -+ -+ self._variantFromVersion() -+ -+ self.os_variant = self._detect_osdict_from_url() -+ -+ # Reset kernel name for sle11 source on s390x -+ if self.arch == "s390x": -+ if self.os_variant == "sles11" or self.os_variant == "sled11": -+ self._hvm_kernel_paths = [("boot/%s/vmrdr.ikr" % self.arch, -+ "boot/%s/initrd" % self.arch)] -+ -+ return True -+ -+ def _get_method_arg(self): -+ return "install" -+ -+ ################################ -+ # osdict autodetection helpers # -+ ################################ -+ -+ def _detect_osdict_from_url(self): -+ root = "opensuse" -+ oses = [n for n in OSDB.list_os() if n.name.startswith(root)] -+ -+ for osobj in oses: -+ codename = osobj.name[len(root):] -+ if re.search("/%s/" % codename, self.uri): -+ return osobj.name -+ return self.os_variant -+ -+ -+class SLESDistro(SuseDistro): -+ urldistro = "sles" -+ -+ -+class SLEDDistro(SuseDistro): -+ urldistro = "sled" -+ -+ -+# Suse image store is harder - we fetch the kernel RPM and a helper -+# RPM and then munge bits together to generate a initrd -+class OpensuseDistro(SuseDistro): -+ urldistro = "opensuse" -+ -+ -+class DebianDistro(Distro): -+ # ex. http://ftp.egr.msu.edu/debian/dists/sarge/main/installer-i386/ -+ # daily builds: http://d-i.debian.org/daily-images/amd64/ -+ name = "Debian" -+ urldistro = "debian" -+ -+ def __init__(self, *args, **kwargs): -+ Distro.__init__(self, *args, **kwargs) -+ -+ self._url_prefix = "" -+ self._treeArch = self._find_treearch() -+ self._installer_dirname = self.name.lower() + "-installer" -+ -+ def _find_treearch(self): -+ for pattern in ["^.*/installer-(\w+)/?$", -+ "^.*/daily-images/(\w+)/?$"]: -+ arch = re.findall(pattern, self.uri) -+ if not arch: -+ continue -+ logging.debug("Found pattern=%s treearch=%s in uri", -+ pattern, arch[0]) -+ return arch[0] -+ -+ # Check for standard 'i386' and 'amd64' which will be -+ # in the URI name for --location $ISO mounts -+ for arch in ["i386", "amd64", "x86_64"]: -+ if arch in self.uri: -+ logging.debug("Found treearch=%s in uri", arch) -+ if arch == "x86_64": -+ arch = "amd64" -+ return arch -+ -+ # Otherwise default to i386 -+ arch = "i386" -+ logging.debug("No treearch found in uri, defaulting to arch=%s", arch) -+ return arch -+ -+ def _set_media_paths(self): -+ self._boot_iso_paths = ["%s/netboot/mini.iso" % self._url_prefix] -+ -+ hvmroot = "%s/netboot/%s/%s/" % (self._url_prefix, -+ self._installer_dirname, -+ self._treeArch) -+ initrd_basename = "initrd.gz" -+ kernel_basename = "linux" -+ if self._treeArch in ["ppc64el"]: -+ kernel_basename = "vmlinux" -+ -+ if self._treeArch == "s390x": -+ hvmroot = "%s/generic/" % self._url_prefix -+ kernel_basename = "kernel.%s" % self.name.lower() -+ initrd_basename = "initrd.%s" % self.name.lower() -+ -+ self._hvm_kernel_paths = [ -+ (hvmroot + kernel_basename, hvmroot + initrd_basename)] -+ -+ xenroot = "%s/netboot/xen/" % self._url_prefix -+ self._xen_kernel_paths = [(xenroot + "vmlinuz", xenroot + "initrd.gz")] -+ -+ def _check_manifest(self, filename): -+ if not self.fetcher.hasFile(filename): -+ return False -+ -+ if self.arch == "s390x": -+ regex = ".*generic/kernel\.%s.*" % self.name.lower() -+ else: -+ regex = ".*%s.*" % self._installer_dirname -+ -+ if not self._fetchAndMatchRegex(filename, regex): -+ logging.debug("Regex didn't match, not a %s distro", self.name) -+ return False -+ -+ return True -+ -+ def _check_info(self, filename): -+ if not self.fetcher.hasFile(filename): -+ return False -+ -+ regex = "%s.*" % self.name -+ -+ if not self._fetchAndMatchRegex(filename, regex): -+ logging.debug("Regex didn't match, not a %s distro", self.name) -+ return False -+ -+ return True -+ -+ def _is_regular_tree(self): -+ # For regular trees -+ if not self._check_manifest("current/images/MANIFEST"): -+ return False -+ -+ self._url_prefix = "current/images" -+ self._set_media_paths() -+ self.os_variant = self._detect_debian_osdict_from_url() -+ -+ return True -+ -+ def _is_daily_tree(self): -+ # For daily trees -+ if not self._check_manifest("daily/MANIFEST"): -+ return False -+ -+ self._url_prefix = "daily" -+ self._set_media_paths() -+ self.os_variant = self._detect_debian_osdict_from_url() -+ -+ return True -+ -+ def _is_install_cd(self): -+ # For install CDs -+ if not self._check_info(".disk/info"): -+ return False -+ -+ if self.arch == "x86_64": -+ kernel_initrd_pair = ("install.amd/vmlinuz", "install.amd/initrd.gz") -+ elif self.arch == "i686": -+ kernel_initrd_pair = ("install.386/vmlinuz", "install.386/initrd.gz") -+ elif self.arch == "s390x": -+ kernel_initrd_pair = ("boot/linux_vm", "boot/root.bin") -+ else: -+ kernel_initrd_pair = ("install/vmlinuz", "install/initrd.gz") -+ self._hvm_kernel_paths += [kernel_initrd_pair] -+ self._xen_kernel_paths += [kernel_initrd_pair] -+ -+ return True -+ -+ def isValidStore(self): -+ return any(check() for check in [ -+ self._is_regular_tree, -+ self._is_daily_tree, -+ self._is_install_cd, -+ ]) -+ -+ -+ ################################ -+ # osdict autodetection helpers # -+ ################################ -+ -+ def _detect_debian_osdict_from_url(self): -+ root = self.name.lower() -+ oses = [n for n in OSDB.list_os() if n.name.startswith(root)] -+ -+ if self._url_prefix == "daily": -+ logging.debug("Appears to be debian 'daily' URL, using latest " -+ "debian OS") -+ return oses[0].name -+ -+ for osobj in oses: -+ if osobj.codename: -+ # Ubuntu codenames look like 'Warty Warthog' -+ codename = osobj.codename.split()[0].lower() -+ else: -+ if " " not in osobj.label: -+ continue -+ # Debian labels look like 'Debian Sarge' -+ codename = osobj.label.split()[1].lower() -+ -+ if ("/%s/" % codename) in self.uri: -+ logging.debug("Found codename=%s in the URL string", codename) -+ return osobj.name -+ -+ logging.debug("Didn't find any known codename in the URL string") -+ return self.os_variant -+ -+ -+class UbuntuDistro(DebianDistro): -+ # http://archive.ubuntu.com/ubuntu/dists/natty/main/installer-amd64/ -+ name = "Ubuntu" -+ urldistro = "ubuntu" -+ -+ def _is_tree_iso(self): -+ # For trees based on ISO's -+ if not self._check_info("install/netboot/version.info"): -+ return False -+ -+ self._url_prefix = "install" -+ self._set_media_paths() -+ self.os_variant = self._detect_debian_osdict_from_url() -+ -+ return True -+ -+ def _is_install_cd(self): -+ # For install CDs -+ if not self._check_info(".disk/info"): -+ return False -+ -+ if not self.arch == "s390x": -+ kernel_initrd_pair = ("linux", "initrd.gz") -+ else: -+ kernel_initrd_pair = ("boot/kernel.ubuntu", "boot/initrd.ubuntu") -+ -+ self._hvm_kernel_paths += [kernel_initrd_pair] -+ self._xen_kernel_paths += [kernel_initrd_pair] -+ -+ return True -+ -+ -+ -+class MandrivaDistro(Distro): -+ # ftp://ftp.uwsg.indiana.edu/linux/mandrake/official/2007.1/x86_64/ -+ name = "Mandriva/Mageia" -+ urldistro = "mandriva" -+ -+ _boot_iso_paths = ["install/images/boot.iso"] -+ _xen_kernel_paths = [] -+ -+ def __init__(self, *args, **kwargs): -+ Distro.__init__(self, *args, **kwargs) -+ self._hvm_kernel_paths = [] -+ -+ # At least Mageia 5 uses arch in the names -+ self._hvm_kernel_paths += [ -+ ("isolinux/%s/vmlinuz" % self.arch, -+ "isolinux/%s/all.rdz" % self.arch)] -+ -+ # Kernels for HVM: valid for releases 2007.1, 2008.*, 2009.0 -+ self._hvm_kernel_paths += [ -+ ("isolinux/alt0/vmlinuz", "isolinux/alt0/all.rdz")] -+ -+ -+ def isValidStore(self): -+ # Don't support any paravirt installs -+ if self.type is not None and self.type != "hvm": -+ return False -+ -+ # Mandriva websites / media appear to have a VERSION -+ # file in top level which we can use as our 'magic' -+ # check for validity -+ if not self.fetcher.hasFile("VERSION"): -+ return False -+ -+ for name in ["Mandriva", "Mageia"]: -+ if self._fetchAndMatchRegex("VERSION", ".*%s.*" % name): -+ return True -+ -+ logging.debug("Regex didn't match, not a %s distro", self.name) -+ return False -+ -+ -+class ALTLinuxDistro(Distro): -+ # altlinux doesn't have installable URLs, so this is just for a -+ # mounted ISO -+ name = "ALT Linux" -+ urldistro = "altlinux" -+ -+ _boot_iso_paths = [("altinst", "live")] -+ _hvm_kernel_paths = [("syslinux/alt0/vmlinuz", "syslinux/alt0/full.cz")] -+ _xen_kernel_paths = [] -+ -+ def isValidStore(self): -+ # Don't support any paravirt installs -+ if self.type is not None and self.type != "hvm": -+ return False -+ -+ if not self.fetcher.hasFile(".disk/info"): -+ return False -+ -+ if self._fetchAndMatchRegex(".disk/info", ".*%s.*" % self.name): -+ return True -+ -+ logging.debug("Regex didn't match, not a %s distro", self.name) -+ return False -+ -+ -+# Build list of all *Distro classes -+def _build_distro_list(): -+ allstores = [] -+ for obj in globals().values(): -+ if type(obj) is type and issubclass(obj, Distro) and obj.name: -+ allstores.append(obj) -+ -+ seen_urldistro = [] -+ for obj in allstores: -+ if obj.urldistro and obj.urldistro in seen_urldistro: -+ raise RuntimeError("programming error: duplicate urldistro=%s" % -+ obj.urldistro) -+ seen_urldistro.append(obj.urldistro) -+ -+ # Always stick GenericDistro at the end, since it's a catchall -+ allstores.remove(GenericDistro) -+ allstores.append(GenericDistro) -+ -+ return allstores -+ -+_allstores = _build_distro_list() diff --git a/system/virt-manager/virt-manager.SlackBuild b/system/virt-manager/virt-manager.SlackBuild index fee8d674ab..7e0852da90 100644 --- a/system/virt-manager/virt-manager.SlackBuild +++ b/system/virt-manager/virt-manager.SlackBuild @@ -7,13 +7,13 @@ # Lots of mods by rworkman for 1.x PRGNAM=virt-manager -VERSION=${VERSION:-1.4.3} +VERSION=${VERSION:-1.5.0} BUILD=${BUILD:-1} TAG=${TAG:-_SBo} if [ -z "$ARCH" ]; then case "$( uname -m )" in - i?86) ARCH=i486 ;; + i?86) ARCH=i586 ;; arm*) ARCH=arm ;; *) ARCH=$( uname -m ) ;; esac @@ -24,8 +24,8 @@ TMP=${TMP:-/tmp/SBo} PKG=$TMP/package-$PRGNAM OUTPUT=${OUTPUT:-/tmp} -if [ "$ARCH" = "i486" ]; then - SLKCFLAGS="-O2 -march=i486 -mtune=i686" +if [ "$ARCH" = "i586" ]; then + SLKCFLAGS="-O2 -march=i586 -mtune=i686" LIBDIRSUFFIX="" elif [ "$ARCH" = "i686" ]; then SLKCFLAGS="-O2 -march=i686 -mtune=i686" @@ -53,9 +53,6 @@ find -L . \ \( -perm 666 -o -perm 664 -o -perm 600 -o -perm 444 -o -perm 440 -o -perm 400 \) \ -exec chmod 644 {} \; -# We don't have gtk+3-3.10, so we cheat -sed -i "s|3\.10|3.8|" ui/gfxdetails.ui ui/netlist.ui ui/addstorage.ui - # Add Slackware support patch -p1 < $CWD/Add-Slackware-to-OS-choices.patch diff --git a/system/virt-manager/virt-manager.info b/system/virt-manager/virt-manager.info index 142455be70..7683ae4d3e 100644 --- a/system/virt-manager/virt-manager.info +++ b/system/virt-manager/virt-manager.info @@ -1,8 +1,8 @@ PRGNAM="virt-manager" -VERSION="1.4.3" +VERSION="1.5.0" HOMEPAGE="http://virt-manager.org/" -DOWNLOAD="http://virt-manager.org/download/sources/virt-manager/virt-manager-1.4.3.tar.gz" -MD5SUM="077916aae947bf2461e7d7d1fb2ddfd3" +DOWNLOAD="http://virt-manager.org/download/sources/virt-manager/virt-manager-1.5.0.tar.gz" +MD5SUM="9e96d99fe10c529ceb93edf14162b6c8" DOWNLOAD_x86_64="" MD5SUM_x86_64="" REQUIRES="libosinfo libvirt-glib libvirt-python gnome-python2-gconf tunctl ipaddr-py python-requests gtk-vnc spice-gtk vte3" |