def test_centos_stream():
release = RedhatRelease(context_wrap(CENTOS_STREAM))
assert release.major == 8
assert release.minor is None
assert release.product == 'CentOS Stream'
assert release.is_centos
assert not release.is_rhel
def test_both():
un = Uname(context_wrap(UNAME))
rel = RedhatRelease(context_wrap(REDHAT_RELEASE))
expected = (7, 2)
result = redhat_release(rel, un)
assert result.major == expected[0]
assert result.minor == expected[1]
def test_httpd_V_RHEL6():
hv1 = HV(context_wrap(HTTPDV1))
hv2 = HWV(context_wrap(HTTPDV2))
hv3 = HEV(context_wrap(HTTPDV3))
ps = PsAuxww(context_wrap(PS_WORKER))
rh = RedhatRelease(context_wrap(RHEL6))
shared = {HV: hv1, HWV: hv2, HEV: hv3, PsAuxww: ps, redhat_release: rh}
result = HttpdV(None, shared)
assert result["Server MPM"] == "worker"
assert result[
"Server version"] == "apache/2.4.6 (red hat enterprise linux)"
assert result["forked"] == "yes (variable process count)"
assert "APR_HAVE_IPV6" in result['Server compiled with']
assert result['Server compiled with']['APR_HAS_MMAP'] is True
assert result['Server compiled with'][
'APR_HAVE_IPV6'] == "IPv4-mapped addresses enabled"
assert result['Server compiled with'][
'DEFAULT_PIDLOG'] == "/run/httpd/httpd.pid"
ps = PsAuxww(context_wrap(PS_EVENT))
shared = {HV: hv1, HWV: hv2, HEV: hv3, PsAuxww: ps, redhat_release: rh}
result = HttpdV(None, shared)
assert result["Server MPM"] == "event"
assert result[
"Server version"] == "apache/2.4.6 (red hat enterprise linux)"
assert result["forked"] == "yes (variable process count)"
assert "APR_HAVE_IPV6" not in result['Server compiled with']
assert result['Server compiled with']['APR_HAS_MMAP'] is True
def os_release_info():
'''
Use insights-core to fetch the os-release or redhat-release info
Returns a tuple of OS name and version
'''
os_family = "Unknown"
os_release = ""
for p in ["/etc/os-release", "/etc/redhat-release"]:
try:
with open(p) as f:
data = f.readlines()
ctx = Context(content=data, path=p, relative_path=p)
if p == "/etc/os-release":
rls = OsRelease(ctx)
os_family = rls.data.get("NAME")
os_release = rls.data.get("VERSION_ID")
elif p == "/etc/redhat-release":
rls = RedhatRelease(ctx)
os_family = rls.product
os_release = rls.version
break
except IOError:
continue
except Exception as e:
logger.warning("Failed to detect OS version: %s", e)
return (os_family, os_release)
def test_rhel6_10():
release = RedhatRelease(context_wrap(REDHAT_RELEASE10))
assert release.raw == REDHAT_RELEASE10
assert release.major == 6
assert release.minor == 10
assert release.version == "6.10"
assert release.is_rhel
assert release.product == "Red Hat Enterprise Linux Server"
def test_centos_7():
release = RedhatRelease(context_wrap(CENTOS_7))
assert release.major == 7
assert release.minor == 6
assert release.product == 'CentOS Linux'
assert release.code_name == 'Core'
assert release.is_centos
assert not release.is_rhel
def test_rhe75_0_14():
release = RedhatRelease(context_wrap(REDHAT_RELEASE3))
assert release.raw == REDHAT_RELEASE3
assert release.major == 7
assert release.minor == 5
assert release.version == "7.5-0.14"
assert release.is_rhel
assert release.product == "Red Hat Enterprise Linux"
def test_rhevh35():
release = RedhatRelease(context_wrap(RHEVH_RHEV35))
assert release.raw == RHEVH_RHEV35
assert release.major == 6
assert release.minor == 7
assert release.version == "6.7"
assert not release.is_rhel
assert release.product == "Red Hat Enterprise Virtualization Hypervisor"
def test_rhvh40():
release = RedhatRelease(context_wrap(RHVH_RHV40))
assert release.raw == RHVH_RHV40
assert release.major == 7
assert release.minor == 3
assert release.version == "7.3"
assert release.is_rhel
assert release.product == "Red Hat Enterprise Linux"
def test_rhe7():
release = RedhatRelease(context_wrap(REDHAT_RELEASE2))
assert release.raw == REDHAT_RELEASE2
assert release.major == 7
assert release.minor == 2
assert release.version == "7.2"
assert release.is_rhel
assert release.product == "Red Hat Enterprise Linux Server"
def test_RedHatRelease_redhat_release():
rel = RedhatRelease(context_wrap(REDHAT_RELEASE))
expected = (7, 2)
result = RedHatRelease(None, rel)
assert result.major == expected[0]
assert result.minor == expected[1]
assert result.rhel == result.rhel7 == '7.2'
assert result.rhel8 is None
def test_httpd_V_failed():
hv1 = HV(context_wrap(HTTPDV1))
hv2 = HWV(context_wrap(HTTPDV2, path='httpd.worker_-V'))
ps = PsAuxcww(context_wrap(PS_EVENT))
rh = RedhatRelease(context_wrap(RHEL6))
with pytest.raises(SkipComponent) as sc:
HttpdV(rh, ps, hv1, None, hv2)
assert "Unable to get the valid `httpd -V` command" in str(sc)
def test_fedora23():
release = RedhatRelease(context_wrap(FEDORA))
assert release.raw == FEDORA
assert release.major == 23
assert release.minor is None
assert release.version == "23"
assert not release.is_rhel
assert release.product == "Fedora"
def test_httpd_V_failed():
hv1 = HV(context_wrap(HTTPDV1))
hv2 = HWV(context_wrap(HTTPDV2))
ps = PsAuxww(context_wrap(PS_EVENT))
rh = RedhatRelease(context_wrap(RHEL6))
shared = {HV: hv1, HWV: hv2, PsAuxww: ps, redhat_release: rh}
with pytest.raises(SkipComponent) as sc:
HttpdV(None, shared)
assert "Unable to get the valid `httpd -V` command" in str(sc)
def user_agent(self):
"""
Generates and returns a string suitable for use as a request user-agent
"""
core_version = "insights-core"
pkg = pkg_resources.working_set.find(pkg_resources.Requirement.parse(core_version))
if pkg is not None:
core_version = "%s %s" % (pkg.project_name, pkg.version)
else:
core_version = "Core %s" % package_info["VERSION"]
client_version = "insights-client"
pkg = pkg_resources.working_set.find(pkg_resources.Requirement.parse(client_version))
if pkg is not None:
client_version = "%s/%s" % (pkg.project_name, pkg.version)
requests_version = None
pkg = pkg_resources.working_set.find(pkg_resources.Requirement.parse("requests"))
if pkg is not None:
requests_version = "%s %s" % (pkg.project_name, pkg.version)
python_version = "%s %s" % (platform.python_implementation(), platform.python_version())
os_family = "Unknown"
os_release = ""
for p in ["/etc/os-release", "/etc/redhat-release"]:
try:
with open(p) as f:
data = f.readlines()
ctx = Context(content=data, path=p, relative_path=p)
if p == "/etc/os-release":
rls = OsRelease(ctx)
os_family = rls.data.get("NAME")
os_release = rls.data.get("VERSION_ID")
elif p == "/etc/redhat-release":
rls = RedhatRelease(ctx)
os_family = rls.product
os_release = rls.version
break
except IOError:
continue
except Exception as e:
logger.warning("Failed to detect OS version: %s", e)
kernel_version = "%s %s" % (platform.system(), platform.release())
ua = "{client_version} ({core_version}; {requests_version}) {os_family} {os_release} ({python_version}; {kernel_version})".format(
client_version=client_version,
core_version=core_version,
python_version=python_version,
os_family=os_family,
os_release=os_release,
kernel_version=kernel_version,
requests_version=requests_version,
)
return ua
def test_RedHatRelease_both():
un = Uname(context_wrap(UNAME))
rel = RedhatRelease(context_wrap(REDHAT_RELEASE))
expected = (7, 2)
result = RedHatRelease(un, rel)
assert result.major == expected[0]
assert result.minor == expected[1]
assert result.rhel == result.rhel7 == '7.2'
assert result.rhel6 is None
assert result.rhel8 is None
def test_rhel_beta():
release = RedhatRelease(context_wrap(REDHAT_RELEASE_BETA))
assert release.raw == REDHAT_RELEASE_BETA
assert release.major == 8
assert release.minor == 5
assert release.version == "8.5"
assert release.is_rhel
assert release.is_beta
assert release.parsed['code_name'] == 'Ootpa'
assert release.product == "Red Hat Enterprise Linux Server"
def test_grub2_grubenv():
grub2 = Grub2Config(context_wrap(GRUB2_TEMPLATE))
grub2env = Grub2Grubenv(context_wrap(GRUBENV))
rhel8 = RedhatRelease(context_wrap(RHEL8))
rhel = RedHatRelease(None, rhel8)
rpms = InstalledRpms(context_wrap(INSTALLED_RPMS_V2))
sys_firmware = LsSysFirmware(context_wrap(SYS_FIRMWARE_DIR_NOEFI))
result = GrubConf(None, grub2, None, None, grub2env, None, rpms, None,
sys_firmware, rhel)
assert len(result.get_grub_cmdlines()) == 1
assert 'noapic' not in result.get_grub_cmdlines()[0]['cmdline']
assert result.version == 2
assert not result.is_efi
def test_httpd_V_RHEL7():
hv1 = HV(context_wrap(HTTPDV1))
hv2 = HWV(context_wrap(HTTPDV2, path='httpd.worker_-V'))
hv3 = HEV(context_wrap(HTTPDV3, path='httpd.event_-V'))
ps = PsAuxww(context_wrap(PS_WORKER))
rh = RedhatRelease(context_wrap(RHEL7))
result = HttpdV(rh, ps, hv1, hv3, hv2)
assert result["Server MPM"] == "prefork"
assert result["Server version"] == "apache/2.2.15 (unix)"
assert result["forked"] == "yes (variable process count)"
assert "APR_HAVE_IPV6" in result['Server compiled with']
assert result['Server compiled with']['APR_HAS_MMAP'] is True
assert result['Server compiled with']['APR_HAVE_IPV6'] == "IPv4-mapped addresses enabled"
assert result['Server compiled with']['DEFAULT_PIDLOG'] == "run/httpd.pid"
def test_grub2_boot_loader_entries():
grub2 = Grub2Config(context_wrap(GRUB2_TEMPLATE))
grub_ble1 = BLE(context_wrap(BOOT_LOADER_ENTRIES_1))
grub_ble2 = BLE(context_wrap(BOOT_LOADER_ENTRIES_2))
grub_bles = BootLoaderEntries([grub_ble1, grub_ble2], None, None)
rhel8 = RedhatRelease(context_wrap(RHEL8))
rhel = RedHatRelease(None, rhel8)
rpms = InstalledRpms(context_wrap(INSTALLED_RPMS_V2))
sys_firmware = LsSysFirmware(context_wrap(SYS_FIRMWARE_DIR_EFI))
result = GrubConf(None, grub2, None, None, grub_bles, rpms, None,
sys_firmware, rhel)
assert len(result.get_grub_cmdlines()) == 2
assert 'noapic' in result.get_grub_cmdlines()[0]['cmdline']
assert result.version == 2
assert result.is_efi
def test_grub2_grubenv_with_kernelopts():
grub2 = Grub2Config(context_wrap(GRUB2_TEMPLATE))
grub_ble3 = BLE(context_wrap(BOOT_LOADER_ENTRIES_3))
grub_bles = BootLoaderEntries([grub_ble3], None, None)
rhel8 = RedhatRelease(context_wrap(RHEL8))
rhel = RedHatRelease(None, rhel8)
rpms = InstalledRpms(context_wrap(INSTALLED_RPMS_V2))
sys_firmware = LsSysFirmware(context_wrap(SYS_FIRMWARE_DIR_NOEFI))
result = GrubConf(None, grub2, None, None, grub_bles, rpms, None,
sys_firmware, rhel)
assert len(result.get_grub_cmdlines()) == 1
assert 'noapic' not in result.get_grub_cmdlines()[0]['cmdline']
assert 'transparent_hugepages' not in result.get_grub_cmdlines(
)[0]['cmdline']
assert result.version == 2
assert not result.is_efi
def test_examples():
release = RedhatRelease(context_wrap(REDHAT_RELEASE2))
globs = {'rh_release': release}
failed, tested = doctest.testmod(redhat_release, globs=globs)
assert failed == 0
def test_redhat_release():
rel = RedhatRelease(context_wrap(REDHAT_RELEASE))
expected = (7, 2)
result = redhat_release(rel, None)
assert result.major == expected[0]
assert result.minor == expected[1]
def test_is_rhel8():
rr = RedhatRelease(context_wrap(REDHAT_RELEASE4))
rel = RR(None, rr)
result = IsRhel8(rel)
assert isinstance(result, IsRhel8)
def test_uname_is_rhel7():
uname = Uname(context_wrap(UNAME))
rr = RedhatRelease(context_wrap(REDHAT_RELEASE3))
rel = RR(uname, rr)
result = IsRhel7(rel)
assert isinstance(result, IsRhel7)
def test_not_rhel8():
rr = RedhatRelease(context_wrap(REDHAT_RELEASE2))
rel = RR(None, rr)
with pytest.raises(SkipComponent) as e:
IsRhel8(rel)
assert "Not RHEL8" in str(e)