path: root/libre/virt-manager/libre.patch

diff --git a/virtManager/oslist.py b/virtManager/oslist.py
index 43d1d27..bd4281e 100644
--- a/virtManager/oslist.py
+++ b/virtManager/oslist.py
@@ -58,6 +58,11 @@ class vmmOSList(vmmGObjectUI):
         os_list_model = Gtk.ListStore(object, str)
 
         all_os = virtinst.OSDB.list_os(sortkey="label")
+        all_os = [os for os in all_os if os.name in [ 'generic'   , \
+                                                      'parabola'  , \
+                                                      'pureos'    , \
+                                                      'trisquel8' , \
+                                                      'trisquel9' ] ]
         # Always put the generic entries at the end of the list
         all_os = list(sorted(all_os, key=_always_show))
 
diff --git a/virtinst/install/urldetect.py b/virtinst/install/urldetect.py
index e303163..50df0af 100644
--- a/virtinst/install/urldetect.py
+++ b/virtinst/install/urldetect.py
@@ -298,422 +298,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 "
-                "debiantesting")
-            return "debiantesting"
-
-        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