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