add existing_ovs_version check

roles/openshift_health_checker/library/rpm_version.py

@@ -0,0 +1,127 @@
+#!/usr/bin/python
+"""
+Ansible module for rpm-based systems determining existing package version information in a host.
+"""
+
+from ansible.module_utils.basic import AnsibleModule
+
+IMPORT_EXCEPTION = None
+try:
+    import rpm  # pylint: disable=import-error
+except ImportError as err:
+    IMPORT_EXCEPTION = err  # in tox test env, rpm import fails
+
+
+class RpmVersionException(Exception):
+    """Base exception class for package version problems"""
+    def __init__(self, message, problem_pkgs=None):
+        Exception.__init__(self, message)
+        self.problem_pkgs = problem_pkgs
+
+
+def main():
+    """Entrypoint for this Ansible module"""
+    module = AnsibleModule(
+        argument_spec=dict(
+            package_list=dict(type="list", required=True),
+        ),
+        supports_check_mode=True
+    )
+
+    if IMPORT_EXCEPTION:
+        module.fail_json(msg="rpm_version module could not import rpm: %s" % IMPORT_EXCEPTION)
+
+    # determine the packages we will look for
+    pkg_list = module.params['package_list']
+    if not pkg_list:
+        module.fail_json(msg="package_list must not be empty")
+
+    # get list of packages available and complain if any
+    # of them are missing or if any errors occur
+    try:
+        pkg_versions = _retrieve_expected_pkg_versions(_to_dict(pkg_list))
+        _check_pkg_versions(pkg_versions, _to_dict(pkg_list))
+    except RpmVersionException as excinfo:
+        module.fail_json(msg=str(excinfo))
+    module.exit_json(changed=False)
+
+
+def _to_dict(pkg_list):
+    return {pkg["name"]: pkg for pkg in pkg_list}
+
+
+def _retrieve_expected_pkg_versions(expected_pkgs_dict):
+    """Search for installed packages matching given pkg names
+    and versions. Returns a dictionary: {pkg_name: [versions]}"""
+
+    transaction = rpm.TransactionSet()
+    pkgs = {}
+
+    for pkg_name in expected_pkgs_dict:
+        matched_pkgs = transaction.dbMatch("name", pkg_name)
+        if not matched_pkgs:
+            continue
+
+        for header in matched_pkgs:
+            if header['name'] == pkg_name:
+                if pkg_name not in pkgs:
+                    pkgs[pkg_name] = []
+
+                pkgs[pkg_name].append(header['version'])
+
+    return pkgs
+
+
+def _check_pkg_versions(found_pkgs_dict, expected_pkgs_dict):
+    invalid_pkg_versions = {}
+    not_found_pkgs = []
+
+    for pkg_name, pkg in expected_pkgs_dict.items():
+        if not found_pkgs_dict.get(pkg_name):
+            not_found_pkgs.append(pkg_name)
+            continue
+
+        found_versions = [_parse_version(version) for version in found_pkgs_dict[pkg_name]]
+        expected_version = _parse_version(pkg["version"])
+        if expected_version not in found_versions:
+            invalid_pkg_versions[pkg_name] = {
+                "found_versions": found_versions,
+                "required_version": expected_version,
+            }
+
+    if not_found_pkgs:
+        raise RpmVersionException(
+            '\n'.join([
+                "The following packages were not found to be installed: {}".format('\n    '.join([
+                    "{}".format(pkg)
+                    for pkg in not_found_pkgs
+                ]))
+            ]),
+            not_found_pkgs,
+        )
+
+    if invalid_pkg_versions:
+        raise RpmVersionException(
+            '\n    '.join([
+                "The following packages were found to be installed with an incorrect version: {}".format('\n'.join([
+                    "    \n{}\n    Required version: {}\n    Found versions: {}".format(
+                        pkg_name,
+                        pkg["required_version"],
+                        ', '.join([version for version in pkg["found_versions"]]))
+                    for pkg_name, pkg in invalid_pkg_versions.items()
+                ]))
+            ]),
+            invalid_pkg_versions,
+        )
+
+
+def _parse_version(version_str):
+    segs = version_str.split('.')
+    if not segs or len(segs) <= 2:
+        return version_str
+
+    return '.'.join(segs[0:2])
+
+
+if __name__ == '__main__':
+    main()

roles/openshift_health_checker/meta/main.yml

@@ -2,3 +2,4 @@
 dependencies:
   - role: openshift_facts
   - role: openshift_repos
+  - role: openshift_version

roles/openshift_health_checker/openshift_checks/ovs_version.py

@@ -0,0 +1,78 @@
+"""
+Ansible module for determining if an installed version of Open vSwitch is incompatible with the
+currently installed version of OpenShift.
+"""
+
+from openshift_checks import OpenShiftCheck, OpenShiftCheckException, get_var
+from openshift_checks.mixins import NotContainerizedMixin
+
+
+class OvsVersion(NotContainerizedMixin, OpenShiftCheck):
+    """Check that packages in a package_list are installed on the host
+    and are the correct version as determined by an OpenShift installation.
+    """
+
+    name = "ovs_version"
+    tags = ["health"]
+
+    openshift_to_ovs_version = {
+        "3.6": "2.6",
+        "3.5": "2.6",
+        "3.4": "2.4",
+    }
+
+    # map major release versions across releases
+    # to a common major version
+    openshift_major_release_version = {
+        "1": "3",
+    }
+
+    @classmethod
+    def is_active(cls, task_vars):
+        """Skip hosts that do not have package requirements."""
+        group_names = get_var(task_vars, "group_names", default=[])
+        master_or_node = 'masters' in group_names or 'nodes' in group_names
+        return super(OvsVersion, cls).is_active(task_vars) and master_or_node
+
+    def run(self, tmp, task_vars):
+        args = {
+            "package_list": [
+                {
+                    "name": "openvswitch",
+                    "version": self.get_required_ovs_version(task_vars),
+                },
+            ],
+        }
+        return self.execute_module("rpm_version", args, task_vars)
+
+    def get_required_ovs_version(self, task_vars):
+        """Return the correct Open vSwitch version for the current OpenShift version"""
+        openshift_version = self._get_openshift_version(task_vars)
+
+        if float(openshift_version) < 3.5:
+            return self.openshift_to_ovs_version["3.4"]
+
+        ovs_version = self.openshift_to_ovs_version.get(str(openshift_version))
+        if ovs_version:
+            return self.openshift_to_ovs_version[str(openshift_version)]
+
+        msg = "There is no recommended version of Open vSwitch for the current version of OpenShift: {}"
+        raise OpenShiftCheckException(msg.format(openshift_version))
+
+    def _get_openshift_version(self, task_vars):
+        openshift_version = get_var(task_vars, "openshift_image_tag")
+        if openshift_version and openshift_version[0] == 'v':
+            openshift_version = openshift_version[1:]
+
+        return self._parse_version(openshift_version)
+
+    def _parse_version(self, version):
+        components = version.split(".")
+        if not components or len(components) < 2:
+            msg = "An invalid version of OpenShift was found for this host: {}"
+            raise OpenShiftCheckException(msg.format(version))
+
+        if components[0] in self.openshift_major_release_version:
+            components[0] = self.openshift_major_release_version[components[0]]
+
+        return '.'.join(components[:2])

roles/openshift_health_checker/test/ovs_version_test.py

@@ -0,0 +1,89 @@
+import pytest
+
+from openshift_checks.ovs_version import OvsVersion, OpenShiftCheckException
+
+
+def test_openshift_version_not_supported():
+    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+        return {}
+
+    openshift_release = '111.7.0'
+
+    task_vars = dict(
+        openshift=dict(common=dict(service_type='origin')),
+        openshift_release=openshift_release,
+        openshift_image_tag='v' + openshift_release,
+        openshift_deployment_type='origin',
+    )
+
+    check = OvsVersion(execute_module=execute_module)
+    with pytest.raises(OpenShiftCheckException) as excinfo:
+        check.run(tmp=None, task_vars=task_vars)
+
+    assert "no recommended version of Open vSwitch" in str(excinfo.value)
+
+
+def test_invalid_openshift_release_format():
+    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+        return {}
+
+    task_vars = dict(
+        openshift=dict(common=dict(service_type='origin')),
+        openshift_image_tag='v0',
+        openshift_deployment_type='origin',
+    )
+
+    check = OvsVersion(execute_module=execute_module)
+    with pytest.raises(OpenShiftCheckException) as excinfo:
+        check.run(tmp=None, task_vars=task_vars)
+    assert "invalid version" in str(excinfo.value)
+
+
+@pytest.mark.parametrize('openshift_release,expected_ovs_version', [
+    ("3.5", "2.6"),
+    ("3.6", "2.6"),
+    ("3.4", "2.4"),
+    ("3.3", "2.4"),
+    ("1.0", "2.4"),
+])
+def test_ovs_package_version(openshift_release, expected_ovs_version):
+    task_vars = dict(
+        openshift=dict(common=dict(service_type='origin')),
+        openshift_release=openshift_release,
+        openshift_image_tag='v' + openshift_release,
+    )
+    return_value = object()
+
+    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+        assert module_name == 'rpm_version'
+        assert "package_list" in module_args
+
+        for pkg in module_args["package_list"]:
+            if pkg["name"] == "openvswitch":
+                assert pkg["version"] == expected_ovs_version
+
+        return return_value
+
+    check = OvsVersion(execute_module=execute_module)
+    result = check.run(tmp=None, task_vars=task_vars)
+    assert result is return_value
+
+
+@pytest.mark.parametrize('group_names,is_containerized,is_active', [
+    (['masters'], False, True),
+    # ensure check is skipped on containerized installs
+    (['masters'], True, False),
+    (['nodes'], False, True),
+    (['masters', 'nodes'], False, True),
+    (['masters', 'etcd'], False, True),
+    ([], False, False),
+    (['etcd'], False, False),
+    (['lb'], False, False),
+    (['nfs'], False, False),
+])
+def test_ovs_version_skip_when_not_master_nor_node(group_names, is_containerized, is_active):
+    task_vars = dict(
+        group_names=group_names,
+        openshift=dict(common=dict(is_containerized=is_containerized)),
+    )
+    assert OvsVersion.is_active(task_vars=task_vars) == is_active

roles/openshift_health_checker/test/rpm_version_test.py

@@ -0,0 +1,82 @@
+import pytest
+import rpm_version
+
+expected_pkgs = {
+    "spam": {
+        "name": "spam",
+        "version": "3.2.1",
+    },
+    "eggs": {
+        "name": "eggs",
+        "version": "3.2.1",
+    },
+}
+
+
+@pytest.mark.parametrize('pkgs, expect_not_found', [
+    (
+        {},
+        ["spam", "eggs"],  # none found
+    ),
+    (
+        {"spam": ["3.2.1", "4.5.1"]},
+        ["eggs"],  # completely missing
+    ),
+    (
+        {
+            "spam": ["3.2.1", "4.5.1"],
+            "eggs": ["3.2.1"],
+        },
+        [],  # all found
+    ),
+])
+def test_check_pkg_found(pkgs, expect_not_found):
+    if expect_not_found:
+        with pytest.raises(rpm_version.RpmVersionException) as e:
+            rpm_version._check_pkg_versions(pkgs, expected_pkgs)
+
+        assert "not found to be installed" in str(e.value)
+        assert set(expect_not_found) == set(e.value.problem_pkgs)
+    else:
+        rpm_version._check_pkg_versions(pkgs, expected_pkgs)
+
+
+@pytest.mark.parametrize('pkgs, expect_not_found', [
+    (
+        {
+            'spam': ['3.2.1'],
+            'eggs': ['3.3.2'],
+        },
+        {
+            "eggs": {
+                "required_version": "3.2",
+                "found_versions": ["3.3"],
+            }
+        },  # not the right version
+    ),
+    (
+        {
+            'spam': ['3.1.2', "3.3.2"],
+            'eggs': ['3.3.2', "1.2.3"],
+        },
+        {
+            "eggs": {
+                "required_version": "3.2",
+                "found_versions": ["3.3", "1.2"],
+            },
+            "spam": {
+                "required_version": "3.2",
+                "found_versions": ["3.1", "3.3"],
+            }
+        },  # not the right version
+    ),
+])
+def test_check_pkg_version_found(pkgs, expect_not_found):
+    if expect_not_found:
+        with pytest.raises(rpm_version.RpmVersionException) as e:
+            rpm_version._check_pkg_versions(pkgs, expected_pkgs)
+
+        assert "found to be installed with an incorrect version" in str(e.value)
+        assert expect_not_found == e.value.problem_pkgs
+    else:
+        rpm_version._check_pkg_versions(pkgs, expected_pkgs)