abslibre/libre/virt-manager/libre.patch

diff --git a/virtManager/oslist.py b/virtManager/oslist.py
index 8796c96..9786fad 100644
--- a/virtManager/oslist.py
+++ b/virtManager/oslist.py
@@ -53,6 +53,11 @@ class vmmOSList(vmmGObjectUI):
         os_list_model = Gtk.ListStore(object, str)
 
         all_os = virtinst.OSDB.list_os()
+        all_os = [os for os in all_os if os.name in [ 'generic'   , \
+                                                      'parabola'  , \
+                                                      'pureos'    , \
+                                                      'trisquel8' , \
+                                                      'trisquel9' ] ]
 
         for os in all_os:
             os_list_model.append([os, "%s (%s)" % (os.label, os.name)])
diff --git a/virtinst/install/urldetect.py b/virtinst/install/urldetect.py
index a73b0bf..1588f0c 100644
--- a/virtinst/install/urldetect.py
+++ b/virtinst/install/urldetect.py
@@ -177,109 +177,6 @@ class _DistroCache(object):
         return True
 
 
-class _SUSEContent(object):
-    """
-    Helper class tracking the SUSE 'content' files
-    """
-    def __init__(self, content_str):
-        self.content_str = content_str
-        self.content_dict = {}
-
-        for line in self.content_str.splitlines():
-            for prefix in ["LABEL", "DISTRO", "VERSION",
-                           "BASEARCHS", "DEFAULTBASE", "REPOID"]:
-                if line.startswith(prefix + " "):
-                    self.content_dict[prefix] = line.split(" ", 1)[1]
-
-        log.debug("SUSE content dict: %s", self.content_dict)
-        self.tree_arch = self._get_tree_arch()
-        self.product_name = self._get_product_name()
-        self.product_version = self._get_product_version()
-        log.debug("SUSE content product_name=%s product_version=%s "
-            "tree_arch=%s", self.product_name, self.product_version,
-            self.tree_arch)
-
-    def _get_tree_arch(self):
-        # Examples:
-        # opensuse 11.4: BASEARCHS i586 x86_64
-        # opensuse 12.3: BASEARCHS i586 x86_64
-        # opensuse 10.3: DEFAULTBASE i586
-        distro_arch = (self.content_dict.get("BASEARCHS") or
-                       self.content_dict.get("DEFAULTBASE"))
-        if not distro_arch and "REPOID" in self.content_dict:
-            distro_arch = self.content_dict["REPOID"].rsplit('/', 1)[1]
-        if not distro_arch:
-            return None  # pragma: no cover
-
-        tree_arch = distro_arch.strip()
-        # Fix for 13.2 official oss repo
-        if tree_arch.find("i586-x86_64") != -1:
-            tree_arch = "x86_64"
-        return tree_arch
-
-    def _get_product_name(self):
-        """
-        Parse the SUSE product name. Examples:
-        SUSE Linux Enterprise Server 11 SP4
-        openSUSE 11.4
-        """
-        # Some field examples in the wild
-        #
-        # opensuse 10.3: LABEL openSUSE 10.3
-        # opensuse 11.4: LABEL openSUSE 11.4
-        # opensuse 12.3: LABEL openSUSE
-        # sles11sp4 DVD: LABEL SUSE Linux Enterprise Server 11 SP4
-        #
-        #
-        # DISTRO cpe:/o:opensuse:opensuse:13.2,openSUSE
-        # DISTRO cpe:/o:suse:sled:12:sp3,SUSE Linux Enterprise Desktop 12 SP3
-        #
-        # As of 2018 all latest distros match only DISTRO and REPOID.
-        product_name = None
-        if "LABEL" in self.content_dict:
-            product_name = self.content_dict["LABEL"]
-        elif "," in self.content_dict.get("DISTRO", ""):
-            product_name = self.content_dict["DISTRO"].rsplit(",", 1)[1]
-
-        log.debug("SUSE content product_name=%s", product_name)
-        return product_name
-
-    def _get_product_version(self):
-        # Some example fields:
-        #
-        # opensuse 10.3: VERSION 10.3
-        # opensuse 12.3: VERSION 12.3
-        # SLES-10-SP4-DVD-x86_64-GM-DVD1.iso: VERSION 10.4-0
-        #
-        # REPOID obsproduct://build.suse.de/SUSE:SLE-11-SP4:GA/SUSE_SLES/11.4/DVD/x86_64
-        # REPOID obsproduct://build.suse.de/SUSE:SLE-12-SP3:GA/SLES/12.3/DVD/aarch64
-        #
-        # As of 2018 all latest distros match only DISTRO and REPOID.
-        if not self.product_name:
-            return None  # pragma: no cover
-
-        distro_version = self.content_dict.get("VERSION", "")
-        if "-" in distro_version:
-            distro_version = distro_version.split('-', 1)[0]
-
-        # Special case, parse version out of a line like this
-        # cpe:/o:opensuse:opensuse:13.2,openSUSE
-        if (not distro_version and
-            re.match("^.*:.*,openSUSE*", self.content_dict["DISTRO"])):
-            distro_version = self.content_dict["DISTRO"].rsplit(
-                    ",", 1)[0].strip().rsplit(":")[4]
-        distro_version = distro_version.strip()
-
-        if "Enterprise" in self.product_name or "SLES" in self.product_name:
-            sle_version = self.product_name.strip().rsplit(' ')[4]
-            if len(self.product_name.strip().rsplit(' ')) > 5:
-                sle_version = (sle_version + '.' +
-                        self.product_name.strip().rsplit(' ')[5][2])
-            distro_version = sle_version
-
-        return distro_version
-
-
 def getDistroStore(guest, fetcher, skip_error):
     log.debug("Finding distro store for location=%s", fetcher.location)
 
@@ -400,422 +297,6 @@ class _DistroTree(object):
         return self.cache.libosinfo_treeobj
 
 
-class _FedoraDistro(_DistroTree):
-    PRETTY_NAME = "Fedora"
-    matching_distros = ["fedora"]
-
-    @classmethod
-    def is_valid(cls, cache):
-        famregex = ".*Fedora.*"
-        return cache.treeinfo_family_regex(famregex)
-
-    def _detect_version(self):
-        latest_variant = "fedora-unknown"
-
-        verstr = self.cache.treeinfo_version
-        if not verstr:  # pragma: no cover
-            log.debug("No treeinfo version? Assume latest_variant=%s",
-                    latest_variant)
-            return latest_variant
-
-        # rawhide trees changed to use version=Rawhide in Apr 2016
-        if verstr in ["development", "rawhide", "Rawhide"]:
-            log.debug("treeinfo version=%s, using latest_variant=%s",
-                    verstr, latest_variant)
-            return latest_variant
-
-        # treeinfo version is just an integer
-        variant = "fedora" + verstr
-        if OSDB.lookup_os(variant):
-            return variant
-
-        log.debug(
-                "variant=%s from treeinfo version=%s not found, "
-                "using latest_variant=%s", variant, verstr, latest_variant)
-        return latest_variant
-
-
-class _RHELDistro(_DistroTree):
-    PRETTY_NAME = "Red Hat Enterprise Linux"
-    matching_distros = ["rhel"]
-    _variant_prefix = "rhel"
-
-    @classmethod
-    def is_valid(cls, cache):
-        # Matches:
-        #   Red Hat Enterprise Linux
-        #   RHEL Atomic Host
-        famregex = ".*(Red Hat Enterprise Linux|RHEL).*"
-        if cache.treeinfo_family_regex(famregex):
-            return True
-
-    def _detect_version(self):
-        if not self.cache.treeinfo_version:  # pragma: no cover
-            log.debug("No treeinfo version? Not setting an os_variant")
-            return
-
-        version, update = self.cache.split_version()
-
-        # start with example base=rhel7, then walk backwards
-        # through the OS list to find the latest os name that matches
-        # this way we handle rhel7.6 from treeinfo when osdict only
-        # knows about rhel7.5
-        base = self._variant_prefix + str(version)
-        while update >= 0:
-            tryvar = base + ".%s" % update
-            if OSDB.lookup_os(tryvar):
-                return tryvar
-            update -= 1
-
-
-class _CentOSDistro(_RHELDistro):
-    PRETTY_NAME = "CentOS"
-    matching_distros = ["centos"]
-    _variant_prefix = "centos"
-
-    @classmethod
-    def is_valid(cls, cache):
-        if cache.treeinfo_family_regex(".*CentOS.*"):
-            return True
-        if cache.treeinfo_family_regex(".*Scientific.*"):
-            return True
-
-
-
-class _SuseDistro(_RHELDistro):
-    PRETTY_NAME = None
-    _suse_regex = []
-    matching_distros = []
-    _variant_prefix = NotImplementedError
-    famregex = NotImplementedError
-
-    @classmethod
-    def is_valid(cls, cache):
-        if cache.treeinfo_family_regex(cls.famregex):
-            return True
-
-        if not cache.checked_for_suse_content:
-            cache.checked_for_suse_content = True
-            content_str = cache.acquire_file_content("content")
-            if content_str is None:
-                return False
-
-            try:
-                cache.suse_content = _SUSEContent(content_str)
-            except Exception as e:  # pragma: no cover
-                log.debug("Error parsing SUSE content file: %s", str(e))
-                return False
-
-        if not cache.suse_content:
-            return False
-        for regex in cls._suse_regex:
-            if re.match(regex, cache.suse_content.product_name or ""):
-                return True
-        return False
-
-    def _set_manual_kernel_paths(self):
-        # We only reach here if no treeinfo was matched
-        tree_arch = self.cache.suse_content.tree_arch
-
-        if re.match(r'i[4-9]86', tree_arch):
-            tree_arch = 'i386'
-
-        oldkern = "linux"
-        oldinit = "initrd"
-        if tree_arch == "x86_64":
-            oldkern += "64"
-            oldinit += "64"
-
-        if self.type == "xen":
-            # Matches Opensuse > 10.2 and sles 10
-            self._kernel_paths.append(
-                ("boot/%s/vmlinuz-xen" % tree_arch,
-                 "boot/%s/initrd-xen" % tree_arch))
-
-        if str(self._os_variant).startswith(("sles11", "sled11")):
-            if tree_arch == "s390x":
-                self._kernel_paths.append(
-                    ("boot/s390x/vmrdr.ikr", "boot/s390x/initrd"))
-            if tree_arch == "ppc64":
-                self._kernel_paths.append(
-                    ("suseboot/linux64", "suseboot/initrd64"))
-
-        # Tested with SLES 12 for ppc64le, all s390x
-        self._kernel_paths.append(
-            ("boot/%s/linux" % tree_arch,
-             "boot/%s/initrd" % tree_arch))
-        # Tested with Opensuse 10.0
-        self._kernel_paths.append(
-            ("boot/loader/%s" % oldkern,
-             "boot/loader/%s" % oldinit))
-        # Tested with Opensuse >= 10.2, 11, and sles 10
-        self._kernel_paths.append(
-            ("boot/%s/loader/linux" % tree_arch,
-             "boot/%s/loader/initrd" % tree_arch))
-
-    def _detect_osdict_from_suse_content(self):
-        if not self.cache.suse_content:
-            return  # pragma: no cover
-
-        distro_version = self.cache.suse_content.product_version
-        if not distro_version:
-            return  # pragma: no cover
-
-        version = distro_version.split('.', 1)[0].strip()
-
-        if str(self._variant_prefix).startswith(("sles", "sled")):
-            sp_version = ""
-            if len(distro_version.split('.', 1)) == 2:
-                sp_version = 'sp' + distro_version.split('.', 1)[1].strip()
-
-            return self._variant_prefix + version + sp_version
-
-        return self._variant_prefix + distro_version
-
-    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
-
-    def _detect_from_treeinfo(self):
-        if not self.cache.treeinfo_name:
-            return
-        if re.search("openSUSE Tumbleweed", self.cache.treeinfo_name):
-            return "opensusetumbleweed"
-
-        version, update = self.cache.split_version()
-        base = self._variant_prefix + str(version)
-        while update >= 0:
-            tryvar = base
-            # SLE doesn't use '.0' for initial releases in
-            # osinfo-db (sles11, sles12, etc)
-            if update > 0 or not base.startswith('sle'):
-                tryvar += ".%s" % update
-            if OSDB.lookup_os(tryvar):
-                return tryvar
-            update -= 1
-
-    def _detect_version(self):
-        var = self._detect_from_treeinfo()
-        if not var:
-            var = self._detect_osdict_from_url()
-        if not var:
-            var = self._detect_osdict_from_suse_content()
-        return var
-
-
-class _SLESDistro(_SuseDistro):
-    PRETTY_NAME = "SLES"
-    matching_distros = ["sles"]
-    _variant_prefix = "sles"
-    _suse_regex = [".*SUSE Linux Enterprise Server*", ".*SUSE SLES*"]
-    famregex = ".*SUSE Linux Enterprise.*"
-
-
-class _SLEDDistro(_SuseDistro):
-    PRETTY_NAME = "SLED"
-    matching_distros = ["sled"]
-    _variant_prefix = "sled"
-    _suse_regex = [".*SUSE Linux Enterprise Desktop*"]
-    famregex = ".*SUSE Linux Enterprise.*"
-
-
-class _OpensuseDistro(_SuseDistro):
-    PRETTY_NAME = "openSUSE"
-    matching_distros = ["opensuse"]
-    _variant_prefix = "opensuse"
-    _suse_regex = [".*openSUSE.*"]
-    famregex = ".*openSUSE.*"
-
-
-class _DebianDistro(_DistroTree):
-    # ex. http://ftp.egr.msu.edu/debian/dists/sarge/main/installer-i386/
-    # daily builds: https://d-i.debian.org/daily-images/amd64/
-    PRETTY_NAME = "Debian"
-    matching_distros = ["debian"]
-    _debname = "debian"
-
-    @classmethod
-    def is_valid(cls, cache):
-        def check_manifest(mfile):
-            is_ubuntu = cls._debname == "ubuntu"
-            if cache.content_regex(mfile, ".*[Uu]buntu.*"):
-                return is_ubuntu
-            return cache.content_regex(mfile, ".*[Dd]ebian.*")
-
-        media_type = None
-        if check_manifest("current/images/MANIFEST"):
-            media_type = "url"
-        elif check_manifest("current/legacy-images/MANIFEST"):
-            media_type = "legacy_url"
-        elif check_manifest("daily/MANIFEST"):
-            media_type = "daily"
-        elif cache.content_regex(".disk/info",
-                "%s.*" % cls._debname.capitalize()):
-            # There's two cases here:
-            # 1) Direct access ISO, attached as CDROM afterwards. We
-            #    use one set of kernels in that case which seem to
-            #    assume the prescence of CDROM media
-            # 2) ISO mounted and exported over URL. We use a different
-            #    set of kernels that expect to boot from the network
-            if cache.fetcher_is_iso():
-                media_type = "disk"
-            else:
-                media_type = "mounted_iso_url"
-
-        if media_type:
-            cache.debian_media_type = media_type
-        return bool(media_type)
-
-
-    def _set_manual_kernel_paths(self):
-        if self.cache.debian_media_type == "disk":
-            self._set_installcd_paths()
-        else:
-            self._set_url_paths()
-
-
-    def _find_treearch(self):
-        for pattern in [r"^.*/installer-(\w+)/?$",
-                        r"^.*/daily-images/(\w+)/?$"]:
-            arch = re.findall(pattern, self.uri)
-            if not arch:
-                continue
-            log.debug("Found pattern=%s treearch=%s in uri",
-                pattern, arch[0])
-            return arch[0]
-
-        # Check for standard arch strings which will be
-        # in the URI name for --location $ISO mounts
-        for arch in ["i386", "amd64", "x86_64", "arm64"]:
-            if arch in self.uri:
-                log.debug("Found treearch=%s in uri", arch)
-                if arch == "x86_64":
-                    arch = "amd64"  # pragma: no cover
-                return arch
-
-        # Otherwise default to i386
-        arch = "i386"
-        log.debug("No treearch found in uri, defaulting to arch=%s", arch)
-        return arch
-
-    def _set_url_paths(self):
-        url_prefix = "current/images"
-        if self.cache.debian_media_type == "daily":
-            url_prefix = "daily"
-        elif self.cache.debian_media_type == "mounted_iso_url":
-            url_prefix = "install"
-        elif self.cache.debian_media_type == "legacy_url":
-            url_prefix = "current/legacy-images"
-
-        tree_arch = self._find_treearch()
-        hvmroot = "%s/netboot/%s-installer/%s/" % (url_prefix,
-                self._debname, tree_arch)
-        initrd_basename = "initrd.gz"
-        kernel_basename = "linux"
-        if tree_arch in ["ppc64el"]:
-            kernel_basename = "vmlinux"
-
-        if tree_arch == "s390x":
-            hvmroot = "%s/generic/" % url_prefix
-            kernel_basename = "kernel.%s" % self._debname
-            initrd_basename = "initrd.%s" % self._debname
-
-
-        if self.type == "xen":
-            xenroot = "%s/netboot/xen/" % url_prefix
-            self._kernel_paths.append(
-                    (xenroot + "vmlinuz", xenroot + "initrd.gz"))
-        self._kernel_paths.append(
-                (hvmroot + kernel_basename, hvmroot + initrd_basename))
-
-    def _set_installcd_paths(self):
-        if self._debname == "ubuntu":
-            if not self.arch == "s390x":
-                kpair = ("install/vmlinuz", "install/initrd.gz")
-            else:
-                kpair = ("boot/kernel.ubuntu", "boot/initrd.ubuntu")
-        elif self.arch == "x86_64":
-            kpair = ("install.amd/vmlinuz", "install.amd/initrd.gz")
-        elif self.arch == "i686":
-            kpair = ("install.386/vmlinuz", "install.386/initrd.gz")
-        elif self.arch == "aarch64":
-            kpair = ("install.a64/vmlinuz", "install.a64/initrd.gz")
-        elif self.arch == "ppc64le":
-            kpair = ("install/vmlinux", "install/initrd.gz")
-        elif self.arch == "s390x":
-            kpair = ("boot/linux_vm", "boot/root.bin")
-        else:
-            kpair = ("install/vmlinuz", "install/initrd.gz")
-        self._kernel_paths += [kpair]
-        return True
-
-    def _detect_version(self):
-        oses = [n for n in OSDB.list_os() if n.name.startswith(self._debname)]
-
-        if self.cache.debian_media_type == "daily":
-            log.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  # pragma: no cover
-                # Debian labels look like 'Debian Sarge'
-                codename = osobj.label.split()[1].lower()
-
-            if ("/%s/" % codename) in self.uri:
-                log.debug("Found codename=%s in the URL string", codename)
-                return osobj.name
-
-
-class _UbuntuDistro(_DebianDistro):
-    # https://archive.ubuntu.com/ubuntu/dists/natty/main/installer-amd64/
-    PRETTY_NAME = "Ubuntu"
-    matching_distros = ["ubuntu"]
-    _debname = "ubuntu"
-
-
-class _MageiaDistro(_DistroTree):
-    # https://distro.ibiblio.org/mageia/distrib/cauldron/x86_64/
-    PRETTY_NAME = "Mageia"
-    matching_distros = ["mageia"]
-
-    @classmethod
-    def is_valid(cls, cache):
-        if not cache.mageia_version:
-            content = cache.acquire_file_content("VERSION")
-            if not content:
-                return False
-
-            m = re.match(r"^Mageia (\d+) .*", content)
-            if not m:
-                return False  # pragma: no cover
-
-            cache.mageia_version = m.group(1)
-
-        return bool(cache.mageia_version)
-
-    def _set_manual_kernel_paths(self):
-        self._kernel_paths += [
-            ("isolinux/%s/vmlinuz" % self.arch,
-             "isolinux/%s/all.rdz" % self.arch)]
-
-    def _detect_version(self):
-        # version is just an integer
-        variant = "mageia" + self.cache.mageia_version
-        if OSDB.lookup_os(variant):
-            return variant
-
-
 class _GenericTreeinfoDistro(_DistroTree):
     """
     Generic catchall class for .treeinfo using distros
@@ -855,15 +336,6 @@ def _build_distro_list(osobj):
     allstores = [
         # Libosinfo takes priority
         _LibosinfoDistro,
-        _FedoraDistro,
-        _RHELDistro,
-        _CentOSDistro,
-        _SLESDistro,
-        _SLEDDistro,
-        _OpensuseDistro,
-        _DebianDistro,
-        _UbuntuDistro,
-        _MageiaDistro,
         # Always stick GenericDistro at the end, since it's a catchall
         _GenericTreeinfoDistro,
     ]
diff --git a/virtinst/osdict.py b/virtinst/osdict.py
index 3be1d10..3be0747 100644
--- a/virtinst/osdict.py
+++ b/virtinst/osdict.py
@@ -132,49 +132,8 @@ class _OSDB(object):
     # This is only for back compatibility with pre-libosinfo support.
     # This should never change.
     _aliases = {
-        "altlinux": "altlinux1.0",
-        "debianetch": "debian4",
-        "debianlenny": "debian5",
-        "debiansqueeze": "debian6",
-        "debianwheezy": "debian7",
-        "freebsd10": "freebsd10.0",
-        "freebsd6": "freebsd6.0",
-        "freebsd7": "freebsd7.0",
-        "freebsd8": "freebsd8.0",
-        "freebsd9": "freebsd9.0",
-        "mandriva2009": "mandriva2009.0",
-        "mandriva2010": "mandriva2010.0",
-        "mbs1": "mbs1.0",
-        "msdos": "msdos6.22",
-        "openbsd4": "openbsd4.2",
-        "opensolaris": "opensolaris2009.06",
-        "opensuse11": "opensuse11.4",
-        "opensuse12": "opensuse12.3",
-        "rhel4": "rhel4.0",
-        "rhel5": "rhel5.0",
-        "rhel6": "rhel6.0",
-        "rhel7": "rhel7.0",
-        "ubuntuhardy": "ubuntu8.04",
-        "ubuntuintrepid": "ubuntu8.10",
-        "ubuntujaunty": "ubuntu9.04",
-        "ubuntukarmic": "ubuntu9.10",
-        "ubuntulucid": "ubuntu10.04",
-        "ubuntumaverick": "ubuntu10.10",
-        "ubuntunatty": "ubuntu11.04",
-        "ubuntuoneiric": "ubuntu11.10",
-        "ubuntuprecise": "ubuntu12.04",
-        "ubuntuquantal": "ubuntu12.10",
-        "ubunturaring": "ubuntu13.04",
-        "ubuntusaucy": "ubuntu13.10",
-        "virtio26": "fedora10",
-        "vista": "winvista",
-        "winxp64": "winxp",
-
         # Old --os-type values
         "linux": "generic",
-        "windows": "winxp",
-        "solaris": "solaris10",
-        "unix": "freebsd9.0",
         "other": "generic",
     }