Merge ~gabrielcocenza/juju-lint:bug/1990885 into juju-lint:master

[Gabriel Cocenza]

added check for hyper converged deployments

- warning for hyper converged deployments with Masakari
- added machines_to_apps field, filter_machines_by_charm
  and filter_lxd_on_machine methods on model_input.
- created subdirectory form checks
- renamed module check_spaces.py to spaces.py

Closes-Bug: #1990885

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

PASSED: Continuous integration, rev:4634d8244782746e93f51d22256c1e811fc50d81
https://jenkins.canonical.com/bootstack/job/lp-juju-lint-ci/11/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1103/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1522/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-juju-lint-ci/11//rebuild

review: Approve (continuous-integration)

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

PASSED: Continuous integration, rev:895444691d9f6c09956114a990cb1b8c0d261da7
https://jenkins.canonical.com/bootstack/job/lp-juju-lint-ci/13/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1112/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1528/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-juju-lint-ci/13//rebuild

review: Approve (continuous-integration)

[JamesLin (jneo8)]

LGTM

review: Approve

[Mert Kirpici (mertkirpici)]

thanks Gabriel. I proposed one suggestion inline.

review: Approve

[Eric Chen (eric-chen)]

Agree with Mert, please change it before we merge it. thanks!

review: Needs Fixing

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

PASSED: Continuous integration, rev:d11c04e32c8c1d34e3f58ade4bf6c6297686773d
https://jenkins.canonical.com/bootstack/job/lp-juju-lint-ci/17/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1123/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1542/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-juju-lint-ci/17//rebuild

review: Approve (continuous-integration)

[Eric Chen (eric-chen)]

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision 52fe9bef72b5aec36de0f320e32c994d8fbd96ed

diff --git a/jujulint/checks/hyper_converged.py b/jujulint/checks/hyper_converged.py
new file mode 100644
index 0000000..0dd5da6
--- /dev/null
+++ b/jujulint/checks/hyper_converged.py
@@ -0,0 +1,38 @@
+#!/usr/bin/python3
+"""Checks if nodes can be Hyper-Converged."""
+
+from collections import defaultdict
+from typing import DefaultDict, Union
+
+from jujulint.model_input import JujuBundleFile, JujuStatusFile
+
+
+# see LP#1990885
+def check_hyper_converged(
+    input_file: Union[JujuBundleFile, JujuStatusFile]
+) -> DefaultDict[str, DefaultDict[str, set]]:
+    """Check if other services are collocated with nova/osd with masakari.
+
+    Hyperconvered is nova/osd collocated with openstack services.
+    Masakari uses ha-cluster to monitor nodes. If the node is not responsive then the
+    node is taken down. This is fine for nova/osd units, but if there are collocated
+    with openstack services this can be problematic.
+
+
+    :param input_file: mapped content of the input file.
+    :type input_file: Union[JujuBundleFile, JujuStatusFile]
+    :return: Services on lxds that are on nova/osd machines.
+    :rtype: DefaultDict[str, DefaultDict[str, set]]
+    """
+    hyper_converged_warning = defaultdict(lambda: defaultdict(set))
+    if "masakari" in input_file.charms:
+        nova_machines = input_file.filter_machines_by_charm("nova-compute")
+        ods_machines = input_file.filter_machines_by_charm("ceph-osd")
+        nova_osd_machines = nova_machines.intersection(ods_machines)
+        if nova_osd_machines:
+            for machine in nova_osd_machines:
+                lxds = input_file.filter_lxd_on_machine(machine)
+                for lxd in lxds:
+                    apps = input_file.machines_to_apps[lxd]
+                    hyper_converged_warning[machine][lxd] = apps
+    return hyper_converged_warning
diff --git a/jujulint/relations.py b/jujulint/checks/relations.py
similarity index 100%
rename from jujulint/relations.py
rename to jujulint/checks/relations.py
diff --git a/jujulint/check_spaces.py b/jujulint/checks/spaces.py
similarity index 100%
rename from jujulint/check_spaces.py
rename to jujulint/checks/spaces.py
diff --git a/jujulint/lint.py b/jujulint/lint.py
index b8fa535..f73b7ea 100755
--- a/jujulint/lint.py
+++ b/jujulint/lint.py
@@ -33,11 +33,12 @@ import yaml
 from attr import attrib, attrs
 from dateutil import relativedelta
 
+import jujulint.checks.hyper_converged as hyper_converged
 import jujulint.util as utils
-from jujulint.check_spaces import Relation, find_space_mismatches
+from jujulint.checks.relations import RelationError, RelationsRulesBootStrap
+from jujulint.checks.spaces import Relation, find_space_mismatches
 from jujulint.logging import Logger
 from jujulint.model_input import input_handler
-from jujulint.relations import RelationError, RelationsRulesBootStrap
 
 VALID_CONFIG_CHECKS = ("isset", "eq", "neq", "gte", "search")
 VALID_LOG_LEVEL = {
@@ -757,6 +758,33 @@ class Linter:
                     }
                 )
 
+    def check_hyper_converged(self, input_file):
+        """Check hyper converged deployments.
+
+        :param input_file: mapped content of the input file.
+        :type input_file: Union[JujuBundleFile, JujuStatusFile]
+        """
+        hyper_converged_warning = hyper_converged.check_hyper_converged(input_file)
+
+        if hyper_converged_warning:
+            for machine in hyper_converged_warning:
+                for lxd in hyper_converged_warning[machine]:
+                    self.message_handler(
+                        {
+                            "id": "hyper-converged-masakari",
+                            "tags": ["hyper-converged", "masakari"],
+                            "message": (
+                                "Deployment has Masakari and the machine: '{}' "
+                                "has nova/osd and the lxd: '{}' with those services {}"
+                            ).format(
+                                machine,
+                                lxd,
+                                sorted(list(hyper_converged_warning[machine][lxd])),
+                            ),
+                        },
+                        log_level=logging.WARNING,
+                    )
+
     def check_charms_ops_mandatory(self, charm):
         """
         Check if a mandatory ops charms is present in the model.
@@ -1352,6 +1380,7 @@ class Linter:
 
             self.check_subs(parsed_yaml["machines"])
             self.check_relations(input_file)
+            self.check_hyper_converged(input_file)
             self.check_charms()
 
             if "relations" in parsed_yaml:
diff --git a/jujulint/model_input.py b/jujulint/model_input.py
index a14551c..8233ebb 100644
--- a/jujulint/model_input.py
+++ b/jujulint/model_input.py
@@ -25,6 +25,7 @@ class BaseFile:
     app_to_charm: Dict = field(default_factory=dict)
     charm_to_app: defaultdict[set] = field(default_factory=lambda: defaultdict(set))
     apps_to_machines: defaultdict[set] = field(default_factory=lambda: defaultdict(set))
+    machines_to_apps: defaultdict[set] = field(default_factory=lambda: defaultdict(set))
 
     def __post_init__(self):
         """Dunder method to map file after instantiating."""
@@ -124,6 +125,20 @@ class BaseFile:
             else set()
         )
 
+    def filter_machines_by_charm(self, charm: str) -> Set:
+        """Filter machines that has a specific charm.
+
+        :param charm: Charm name.
+        :type charm: str
+        :return: Machines that contains the charm.
+        :rtype: Set
+        """
+        charm_machines = set()
+        charm_apps = self.charm_to_app[charm]
+        for charm_app in charm_apps:
+            charm_machines.update(self.apps_to_machines[charm_app])
+        return charm_machines
+
     def map_machines(self):
         """Map machines method to be implemented.
 
@@ -158,6 +173,17 @@ class BaseFile:
         """
         raise NotImplementedError(f"{self.__class__.__name__} missing: sorted_machines")
 
+    def filter_lxd_on_machine(self, machine: str):
+        """Lxd containers on a machine.
+
+        :param machine: machine id.
+        :type machine: str
+        :raises NotImplementedError: Raise if not implemented on child classes.
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} missing: filter_lxd_on_machine"
+        )
+
 
 @dataclass
 class JujuStatusFile(BaseFile):
@@ -176,9 +202,12 @@ class JujuStatusFile(BaseFile):
             for unit in units:
                 machine = units[unit].get("machine")
                 self.apps_to_machines[app].add(machine)
+                self.machines_to_apps[machine].add(app)
                 subordinates = units[unit].get("subordinates", {})
                 for sub in subordinates:
-                    self.apps_to_machines[sub.split("/")[0]].add(machine)
+                    sub_name = sub.split("/")[0]
+                    self.apps_to_machines[sub_name].add(machine)
+                    self.machines_to_apps[machine].add(sub_name)
 
     @staticmethod
     def sorted_machines(machine: str) -> Tuple[int, str, int]:
@@ -218,6 +247,20 @@ class JujuStatusFile(BaseFile):
             apps_related.update(relations.get(endpoint, []))
         return apps_related
 
+    def filter_lxd_on_machine(self, machine: str) -> Set:
+        """Lxd containers on a machine.
+
+        :param machine: machine id.
+        :type machine: str
+        :return: lxd containers in the machine.
+        :rtype: Set
+        """
+        return {
+            lxd_machine
+            for lxd_machine in self.machines
+            if "lxd" in lxd_machine and lxd_machine.split("/")[0] == machine
+        }
+
 
 @dataclass
 class JujuBundleFile(BaseFile):
@@ -241,18 +284,26 @@ class JujuBundleFile(BaseFile):
         for app in self.applications_data:
             machines = self.applications_data[app].get("to", [])
             self.apps_to_machines[app].update(machines)
+            for machine in machines:
+                self.machines_to_apps[machine].add(app)
         # NOTE(gabrielcocenza) subordinates won't have the 'to' field because
         # they are deployed thru relations.
         subordinates = {
             sub for sub, machines in self.apps_to_machines.items() if machines == set()
         }
         for relation in self.relations_data:
-            app_1, endpoint_1, app_2, endpoint_2 = self.split_relation(relation)
+            app_1, _, app_2, _ = self.split_relation(relation)
             # update with the machines of the application that the subordinate charm relate.
             if app_1 in subordinates:
-                self.apps_to_machines[app_1].update(self.apps_to_machines[app_2])
+                sub_machines = self.apps_to_machines[app_2]
+                self.apps_to_machines[app_1].update(sub_machines)
+                for sub_machine in sub_machines:
+                    self.machines_to_apps[sub_machine].add(app_1)
             elif app_2 in subordinates:
+                sub_machines = self.apps_to_machines[app_1]
                 self.apps_to_machines[app_2].update(self.apps_to_machines[app_1])
+                for sub_machine in sub_machines:
+                    self.machines_to_apps[sub_machine].add(app_2)
 
     @staticmethod
     def sorted_machines(machine: str) -> Tuple[int, str]:
@@ -303,6 +354,20 @@ class JujuBundleFile(BaseFile):
                     apps_related.add(app_1_ep_1.split(":")[0])
         return apps_related
 
+    def filter_lxd_on_machine(self, machine: str) -> Set:
+        """Lxd containers on a machine.
+
+        :param machine: machine id.
+        :type machine: str
+        :return: lxd containers in the machine.
+        :rtype: Set
+        """
+        return {
+            lxd_machine
+            for lxd_machine in self.machines
+            if "lxd" in lxd_machine and lxd_machine.split(":")[1] == machine
+        }
+
 
 def input_handler(
     parsed_yaml: Dict[str, Any], applications_key: str
diff --git a/tests/unit/conftest.py b/tests/unit/conftest.py
index b49a4b2..0f09bba 100644
--- a/tests/unit/conftest.py
+++ b/tests/unit/conftest.py
@@ -242,17 +242,31 @@ def rules_files():
 
 
 @pytest.fixture
-def input_files(parsed_yaml_status, parsed_yaml_bundle):
+def input_files(
+    parsed_yaml_status,
+    parsed_yaml_bundle,
+    parsed_hyper_converged_yaml_status,
+    parsed_hyper_converged_yaml_bundle,
+):
     return {
         "juju-status": JujuStatusFile(
             applications_data=parsed_yaml_status["applications"],
             machines_data=parsed_yaml_status["machines"],
         ),
+        "juju-status-hyper-converged": JujuStatusFile(
+            applications_data=parsed_hyper_converged_yaml_status["applications"],
+            machines_data=parsed_hyper_converged_yaml_status["machines"],
+        ),
         "juju-bundle": JujuBundleFile(
             applications_data=parsed_yaml_bundle["applications"],
             machines_data=parsed_yaml_bundle["machines"],
             relations_data=parsed_yaml_bundle["relations"],
         ),
+        "juju-bundle-parsed-hyper-converged": JujuBundleFile(
+            applications_data=parsed_hyper_converged_yaml_bundle["applications"],
+            machines_data=parsed_hyper_converged_yaml_bundle["machines"],
+            relations_data=parsed_hyper_converged_yaml_bundle["relations"],
+        ),
     }
 
 
@@ -476,3 +490,325 @@ def parsed_yaml_bundle():
             ],
         ],
     }
+
+
[e-mail]
+def parsed_hyper_converged_yaml_status():
+    """Representation of a hyper converged model with masakari."""
+    return {
+        "machines": {
+            "0": {
+                "juju-status": {"current": "started"},
+                "machine-status": {"current": "running"},
+                "modification-status": {
+                    "current": "idle",
+                },
+                "containers": {
+                    "0/lxd/0": {
+                        "juju-status": {"current": "started"},
+                        "machine-status": {"current": "running"},
+                        "modification-status": {"current": "applied"},
+                        "constraints": "arch=amd64 spaces=",
+                        "hardware": "availability-zone=nova",
+                    },
+                    "0/lxd/1": {
+                        "juju-status": {"current": "started"},
+                        "machine-status": {"current": "running"},
+                        "modification-status": {"current": "applied"},
+                        "constraints": "arch=amd64 spaces=",
+                        "hardware": "availability-zone=nova",
+                    },
+                },
+                "constraints": "arch=amd64 mem=4096M",
+                "hardware": "arch=amd64 cores=2 mem=4096M root-disk=40960M availability-zone=nova",
+            },
+            "1": {
+                "juju-status": {"current": "started"},
+                "machine-status": {"current": "running"},
+                "modification-status": {"current": "idle"},
+                "constraints": "arch=amd64 mem=4096M",
+                "hardware": "arch=amd64 cores=2 mem=4096M root-disk=40960M availability-zone=nova",
+            },
+            "2": {
+                "juju-status": {"current": "started"},
+                "machine-status": {"current": "running"},
+                "modification-status": {"current": "idle"},
+                "constraints": "arch=amd64 mem=4096M",
+                "hardware": "arch=amd64 cores=2 mem=4096M root-disk=40960M availability-zone=nova",
+            },
+            "3": {
+                "juju-status": {"current": "started"},
+                "machine-status": {"current": "running"},
+                "modification-status": {"current": "idle"},
+                "constraints": "arch=amd64",
+                "hardware": "arch=amd64 cores=1 mem=2048M root-disk=20480M availability-zone=nova",
+            },
+        },
+        "applications": {
+            "ceilometer": {
+                "charm": "ceilometer",
+                "charm-name": "ceilometer",
+                "application-status": {"current": "active"},
+                "relations": {"cluster": ["ceilometer"]},
+                "units": {
+                    "ceilometer/0": {
+                        "workload-status": {"current": "active"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "0/lxd/0",
+                    }
+                },
+                "endpoint-bindings": {
+                    "": "alpha",
+                    "admin": "alpha",
+                    "amqp": "alpha",
+                    "amqp-listener": "alpha",
+                    "ceilometer-service": "alpha",
+                    "certificates": "alpha",
+                    "cluster": "alpha",
+                    "event-service": "alpha",
+                    "ha": "alpha",
+                    "identity-credentials": "alpha",
+                    "identity-notifications": "alpha",
+                    "identity-service": "alpha",
+                    "internal": "alpha",
+                    "metric-service": "alpha",
+                    "nrpe-external-master": "alpha",
+                    "public": "alpha",
+                    "shared-db": "alpha",
+                },
+            },
+            "ceph-mon": {
+                "charm": "ceph-mon",
+                "charm-name": "ceph-mon",
+                "application-status": {"current": "active"},
+                "relations": {
+                    "client": ["nova-compute"],
+                    "mon": ["ceph-mon"],
+                    "osd": ["ceph-osd"],
+                },
+                "units": {
+                    "ceph-mon/0": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "0",
+                    },
+                    "ceph-mon/1": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "1",
+                    },
+                    "ceph-mon/2": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "2",
+                    },
+                },
+                "endpoint-bindings": {
+                    "": "alpha",
+                    "admin": "alpha",
+                    "bootstrap-source": "alpha",
+                    "client": "alpha",
+                    "cluster": "alpha",
+                    "dashboard": "alpha",
+                    "mds": "alpha",
+                    "mon": "alpha",
+                    "nrpe-external-master": "alpha",
+                    "osd": "alpha",
+                    "prometheus": "alpha",
+                    "public": "alpha",
+                    "radosgw": "alpha",
+                    "rbd-mirror": "alpha",
+                },
+            },
+            "ceph-osd": {
+                "charm": "ceph-osd",
+                "charm-name": "ceph-osd",
+                "application-status": {"current": "active"},
+                "relations": {"mon": ["ceph-mon"]},
+                "units": {
+                    "ceph-osd/0": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "0",
+                    },
+                    "ceph-osd/1": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "1",
+                    },
+                    "ceph-osd/2": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "2",
+                    },
+                },
+                "endpoint-bindings": {
+                    "": "alpha",
+                    "cluster": "alpha",
+                    "mon": "alpha",
+                    "nrpe-external-master": "alpha",
+                    "public": "alpha",
+                    "secrets-storage": "alpha",
+                },
+            },
+            "heat": {
+                "charm": "heat",
+                "series": "focal",
+                "charm-name": "heat",
+                "application-status": {"current": "active"},
+                "relations": {"cluster": ["heat"]},
+                "units": {
+                    "heat/0": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "0/lxd/1",
+                    }
+                },
+                "endpoint-bindings": {
+                    "": "alpha",
+                    "admin": "alpha",
+                    "amqp": "alpha",
+                    "certificates": "alpha",
+                    "cluster": "alpha",
+                    "ha": "alpha",
+                    "heat-plugin-subordinate": "alpha",
+                    "identity-service": "alpha",
+                    "internal": "alpha",
+                    "nrpe-external-master": "alpha",
+                    "public": "alpha",
+                    "shared-db": "alpha",
+                },
+            },
+            "masakari": {
+                "charm": "masakari",
+                "charm-name": "masakari",
+                "application-status": {"current": "active"},
+                "relations": {"cluster": ["masakari"]},
+                "units": {
+                    "masakari/0": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "3",
+                    }
+                },
+                "endpoint-bindings": {
+                    "": "alpha",
+                    "admin": "alpha",
+                    "amqp": "alpha",
+                    "certificates": "alpha",
+                    "cluster": "alpha",
+                    "ha": "alpha",
+                    "identity-service": "alpha",
+                    "internal": "alpha",
+                    "public": "alpha",
+                    "shared-db": "alpha",
+                },
+            },
+            "nova-compute": {
+                "charm": "nova-compute",
+                "charm-name": "nova-compute",
+                "application-status": {"current": "active"},
+                "relations": {"ceph": ["ceph-mon"], "compute-peer": ["nova-compute"]},
+                "units": {
+                    "nova-compute/0": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "0",
+                    },
+                    "nova-compute/1": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "1",
+                    },
+                    "nova-compute/2": {
+                        "workload-status": {"current": "idle"},
+                        "juju-status": {"current": "idle"},
+                        "machine": "2",
+                    },
+                },
+                "endpoint-bindings": {
+                    "": "alpha",
+                    "amqp": "alpha",
+                    "ceph": "alpha",
+                    "ceph-access": "alpha",
+                    "cloud-compute": "alpha",
+                    "cloud-credentials": "alpha",
+                    "compute-peer": "alpha",
+                    "ephemeral-backend": "alpha",
+                    "image-service": "alpha",
+                    "internal": "alpha",
+                    "ironic-api": "alpha",
+                    "lxd": "alpha",
+                    "migration": "alpha",
+                    "neutron-plugin": "alpha",
+                    "nova-ceilometer": "alpha",
+                    "nrpe-external-master": "alpha",
+                    "secrets-storage": "alpha",
+                },
+            },
+        },
+    }
+
+
[e-mail]
+def parsed_hyper_converged_yaml_bundle():
+    """Representation of a hyper converged model with masakari."""
+    return {
+        "series": "focal",
+        "applications": {
+            "ceilometer": {
+                "charm": "ceilometer",
+                "num_units": 1,
+                "to": ["lxd:0"],
+                "constraints": "arch=amd64",
+            },
+            "ceph-mon": {
+                "charm": "ceph-mon",
+                "num_units": 3,
+                "to": ["0", "1", "2"],
+                "constraints": "arch=amd64",
+            },
+            "ceph-osd": {
+                "charm": "ceph-osd",
+                "num_units": 3,
+                "to": ["0", "1", "2"],
+                "constraints": "arch=amd64 mem=4096",
+                "storage": {
+                    "bluestore-db": "loop,0,1024",
+                    "bluestore-wal": "loop,0,1024",
+                    "osd-devices": "loop,0,1024",
+                    "osd-journals": "loop,0,1024",
+                },
+            },
+            "heat": {
+                "charm": "heat",
+                "resources": {"policyd-override": 0},
+                "num_units": 1,
+                "to": ["lxd:0"],
+                "constraints": "arch=amd64",
+            },
+            "masakari": {
+                "charm": "masakari",
+                "num_units": 1,
+                "to": ["3"],
+                "constraints": "arch=amd64",
+            },
+            "nova-compute": {
+                "charm": "nova-compute",
+                "num_units": 3,
+                "to": ["0", "1", "2"],
+                "constraints": "arch=amd64",
+                "storage": {"ephemeral-device": "loop,0,10240"},
+            },
+        },
+        "machines": {
+            "0": {"constraints": "arch=amd64 mem=4096"},
+            "1": {"constraints": "arch=amd64 mem=4096"},
+            "2": {"constraints": "arch=amd64 mem=4096"},
+            "3": {"constraints": "arch=amd64"},
+        },
+        "relations": [
+            ["ceph-mon:client", "nova-compute:ceph"],
+            ["ceph-mon:osd", "ceph-osd:mon"],
+        ],
+    }
diff --git a/tests/unit/test_hyper_converged.py b/tests/unit/test_hyper_converged.py
new file mode 100644
index 0000000..751af7a
--- /dev/null
+++ b/tests/unit/test_hyper_converged.py
@@ -0,0 +1,32 @@
+from collections import defaultdict
+
+import pytest
+
+from jujulint.checks import hyper_converged
+
+
[e-mail](
+    "masakari, input_file_type",
+    [
+        (True, "juju-status-hyper-converged"),
+        (False, "juju-status-hyper-converged"),
+        (True, "juju-bundle-parsed-hyper-converged"),
+        (False, "juju-bundle-parsed-hyper-converged"),
+    ],
+)
+def test_check_hyper_converged(input_files, masakari, input_file_type):
+    """Test hyper_converged models."""
+    input_file = input_files[input_file_type]
+    expected_result = defaultdict(lambda: defaultdict(set))
+    if masakari and "juju-status" in input_file_type:
+        expected_result["0"]["0/lxd/0"] = {"ceilometer"}
+        expected_result["0"]["0/lxd/1"] = {"heat"}
+    elif masakari and "juju-bundle" in input_file_type:
+        expected_result["0"]["lxd:0"] = {"ceilometer", "heat"}
+    else:
+        # remove masakari from input file
+        del input_file.applications_data["masakari"]
+        del input_file.machines_data["3"]
+        input_file.charms = set()
+        input_file.map_file()
+    assert hyper_converged.check_hyper_converged(input_file) == expected_result
diff --git a/tests/unit/test_input.py b/tests/unit/test_input.py
index 682b664..f06ff4b 100644
--- a/tests/unit/test_input.py
+++ b/tests/unit/test_input.py
@@ -51,6 +51,18 @@ def test_file_inputs(input_files, input_file_type):
                 "keystone": {"lxd:1"},
             },
         },
+        "machines_to_apps": {
+            "juju-status": {
+                "0": {"nrpe-host", "elasticsearch"},
+                "1": {"ubuntu", "nrpe-host"},
+                "1/lxd/0": {"nrpe-container", "keystone"},
+            },
+            "juju-bundle": {
+                "0": {"nrpe-host", "elasticsearch"},
+                "1": {"ubuntu", "nrpe-host"},
+                "lxd:1": {"nrpe-container", "keystone"},
+            },
+        },
     }
     assert input_file.applications == expected_output["applications"]
     assert input_file.machines == expected_output["machines"][input_file_type]
@@ -58,6 +70,10 @@ def test_file_inputs(input_files, input_file_type):
         input_file.apps_to_machines
         == expected_output["apps_to_machines"][input_file_type]
     )
+    assert (
+        input_file.machines_to_apps
+        == expected_output["machines_to_apps"][input_file_type]
+    )
     assert input_file.charms == expected_output["charms"]
     assert input_file.app_to_charm == expected_output["app_to_charm"]
     assert input_file.charm_to_app == expected_output["charm_to_app"]
@@ -207,6 +223,48 @@ def test_input_handler(parsed_yaml, expected_output, request):
     )
 
 
[e-mail]("input_file_type", ["juju-status", "juju-bundle"])
+def test_filter_machines_by_charm(input_files, input_file_type):
+    """Test filter_machines_by_charm method."""
+    input_file = input_files[input_file_type]
+    if input_file_type == "juju-status":
+        expected_output = {
+            "nrpe": {"0", "1", "1/lxd/0"},
+            "keystone": {"1/lxd/0"},
+            "ubuntu": {"1"},
+            "elasticsearch": {"0"},
+        }
+    else:
+        expected_output = {
+            "nrpe": {"0", "1", "lxd:1"},
+            "keystone": {"lxd:1"},
+            "ubuntu": {"1"},
+            "elasticsearch": {"0"},
+        }
+    for charm in input_file.charms:
+        assert input_file.filter_machines_by_charm(charm) == expected_output[charm]
+
+
[e-mail]("input_file_type", ["juju-status", "juju-bundle"])
+def test_filter_lxd_on_machine(input_files, input_file_type):
+    """Test filter_lxd_on_machine method."""
+    input_file = input_files[input_file_type]
+    if input_file_type == "juju-status":
+        expected_output = {
+            "0": set(),
+            "1": {"1/lxd/0"},
+            "1/lxd/0": set(),
+        }
+    else:
+        expected_output = {
+            "0": set(),
+            "1": {"lxd:1"},
+            "lxd:1": set(),
+        }
+    for machine in input_file.machines:
+        assert input_file.filter_lxd_on_machine(machine) == expected_output[machine]
+
+
 def test_raise_not_implemented_methods(parsed_yaml_status):
     # declare a new input class
     @dataclass
@@ -231,3 +289,6 @@ def test_raise_not_implemented_methods(parsed_yaml_status):
 
     with pytest.raises(NotImplementedError):
         new_input.sorted_machines("0")
+
+    with pytest.raises(NotImplementedError):
+        new_input.filter_lxd_on_machine("0")
diff --git a/tests/unit/test_jujulint.py b/tests/unit/test_jujulint.py
index 77dbb5e..c87722d 100644
--- a/tests/unit/test_jujulint.py
+++ b/tests/unit/test_jujulint.py
@@ -7,7 +7,8 @@ from unittest import mock
 import pytest
 import yaml
 
-from jujulint import check_spaces, lint, relations
+from jujulint import lint
+from jujulint.checks import relations, spaces
 from jujulint.lint import VALID_LOG_LEVEL
 
 
@@ -1424,7 +1425,7 @@ applications:
         This warning should be triggerred if some applications have bindings and some
         dont.
         """
-        logger_mock = mocker.patch.object(check_spaces, "LOGGER")
+        logger_mock = mocker.patch.object(spaces, "LOGGER")
 
         app_without_binding = "prometheus-app"
         bundle = {
@@ -1458,7 +1459,7 @@ applications:
         mentioned explicitly will be bound to this default space.
         Juju lint should raise warning if bundles do not define default space.
         """
-        logger_mock = mocker.patch.object(check_spaces, "LOGGER")
+        logger_mock = mocker.patch.object(spaces, "LOGGER")
         app_without_default_space = "telegraf-app"
 
         bundle = {
@@ -1490,7 +1491,7 @@ applications:
 
     def test_check_spaces_multi_model_warning(self, linter, mocker):
         """Test that check_spaces shows warning if some application are from another model."""
-        logger_mock = mocker.patch.object(check_spaces, "LOGGER")
+        logger_mock = mocker.patch.object(spaces, "LOGGER")
 
         app_another_model = "prometheus-app"
         bundle = {
@@ -1745,3 +1746,60 @@ applications:
             logger_mock.assert_has_calls(
                 [mocker.call(expected_message, level=logging.ERROR)]
             )
+
+    @pytest.mark.parametrize(
+        "input_file_type",
+        ["juju-status-hyper-converged", "juju-bundle-parsed-hyper-converged"],
+    )
+    def test_check_hyper_converged(self, linter, input_files, mocker, input_file_type):
+        """Test check_hyper_converged."""
+        input_file = input_files[input_file_type]
+        mock_message_handler = mocker.patch("jujulint.lint.Linter.message_handler")
+        msg = (
+            "Deployment has Masakari and the machine: '{}' "
+            "has nova/osd and the lxd: '{}' with those services {}"
+        )
+        expected_output = [
+            mocker.call(
+                {
+                    "id": "hyper-converged-masakari",
+                    "tags": ["hyper-converged", "masakari"],
+                    "message": msg.format(
+                        "0",
+                        "lxd:0",
+                        ["ceilometer", "heat"],
+                    ),
+                },
+                log_level=logging.WARNING,
+            )
+        ]
+        if "juju-status" in input_file_type:
+            expected_output = [
+                mocker.call(
+                    {
+                        "id": "hyper-converged-masakari",
+                        "tags": ["hyper-converged", "masakari"],
+                        "message": msg.format(
+                            "0",
+                            "0/lxd/0",
+                            ["ceilometer"],
+                        ),
+                    },
+                    log_level=logging.WARNING,
+                ),
+                mocker.call(
+                    {
+                        "id": "hyper-converged-masakari",
+                        "tags": ["hyper-converged", "masakari"],
+                        "message": msg.format(
+                            "0",
+                            "0/lxd/1",
+                            ["heat"],
+                        ),
+                    },
+                    log_level=logging.WARNING,
+                ),
+            ]
+
+        linter.check_hyper_converged(input_file)
+        mock_message_handler.assert_has_calls(expected_output, any_order=True)
diff --git a/tests/unit/test_relations.py b/tests/unit/test_relations.py
index f13d544..121fe9e 100644
--- a/tests/unit/test_relations.py
+++ b/tests/unit/test_relations.py
@@ -2,7 +2,7 @@
 """Test the relations module."""
 import pytest
 
-from jujulint import relations
+from jujulint.checks import relations
 
 CHARM_TO_APP = {"nrpe-host", "nrpe-container"}
 CHARM = "nrpe"
@@ -352,7 +352,7 @@ def test_relations_raise_not_implemented(input_files, mocker):
     """Ensure that a new class that not implement mandatory methods raises error."""
     logger_mock = mocker.patch.object(relations, "LOGGER")
     mocker.patch(
-        "jujulint.relations.RelationRule.relation_exist_check",
+        "jujulint.checks.relations.RelationRule.relation_exist_check",
         side_effect=NotImplementedError(),
     )
     input_file = input_files["juju-status"]
diff --git a/tests/unit/test_check_spaces.py b/tests/unit/test_spaces.py
similarity index 80%
rename from tests/unit/test_check_spaces.py
rename to tests/unit/test_spaces.py
index 9b77e66..db16505 100644
--- a/tests/unit/test_check_spaces.py
+++ b/tests/unit/test_spaces.py
@@ -1,9 +1,9 @@
-"""Tests for check_spaces.py module."""
+"""Tests for spaces.py module."""
 from unittest.mock import call
 
 import pytest
 
-from jujulint import check_spaces
+from jujulint.checks import spaces
 
 
 def test_relation_init():
@@ -11,7 +11,7 @@ def test_relation_init():
     ep_1 = "Endpoint 1"
     ep_2 = "Endpoint 2"
 
-    relation = check_spaces.Relation(ep_1, ep_2)
+    relation = spaces.Relation(ep_1, ep_2)
 
     assert relation.endpoint1 == ep_1
     assert relation.endpoint2 == ep_2
@@ -23,7 +23,7 @@ def test_relation_str():
     ep_2 = "Endpoint 2"
     expected_str = "Relation({} - {})".format(ep_1, ep_2)
 
-    relation = check_spaces.Relation(ep_1, ep_2)
+    relation = spaces.Relation(ep_1, ep_2)
 
     assert str(relation) == expected_str
 
@@ -63,8 +63,8 @@ def test_relation_str():
 )
 def test_relation_eq(rel_1_ep_1, rel_1_ep_2, rel_2_ep_1, rel_2_ep_2, expected_result):
     """Test equality operator of Relation class. Only return true if both endpoints match."""
-    relation_1 = check_spaces.Relation(rel_1_ep_1, rel_1_ep_2)
-    relation_2 = check_spaces.Relation(rel_2_ep_1, rel_2_ep_2)
+    relation_1 = spaces.Relation(rel_1_ep_1, rel_1_ep_2)
+    relation_2 = spaces.Relation(rel_2_ep_1, rel_2_ep_2)
 
     assert (relation_1 == relation_2) == expected_result
 
@@ -74,7 +74,7 @@ def test_relation_endpoints_prop():
     ep_1 = "Endpoint 1"
     ep_2 = "Endpoint 2"
 
-    relation = check_spaces.Relation(ep_1, ep_2)
+    relation = spaces.Relation(ep_1, ep_2)
 
     assert relation.endpoints == [ep_1, ep_2]
 
@@ -105,7 +105,7 @@ def test_space_mismatch_init(input_order, output_order):
     This test also verifies that spaces in SpaceMismatch instance are ordered
     alphabetically based on the endpoint name.
     """
-    mismatch_instance = check_spaces.SpaceMismatch(*input_order)
+    mismatch_instance = spaces.SpaceMismatch(*input_order)
 
     # Assert that endpoints are alphabetically reordered
     assert mismatch_instance.endpoint1 == output_order[0]
@@ -124,7 +124,7 @@ def test_space_mismatch_str():
         ep_1, space_1, ep_2, space_2
     )
 
-    mismatch_instance = check_spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
+    mismatch_instance = spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
 
     assert str(mismatch_instance) == expected_str
 
@@ -136,9 +136,9 @@ def test_space_mismatch_relation_prop():
     space_1 = "Space 1"
     space_2 = "Space 2"
 
-    expected_relation = check_spaces.Relation(ep_1, ep_2)
+    expected_relation = spaces.Relation(ep_1, ep_2)
 
-    mismatch_instance = check_spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
+    mismatch_instance = spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
 
     assert mismatch_instance.relation == expected_relation
 
@@ -156,9 +156,9 @@ def test_space_mismatch_get_charm_relation():
 
     app_map = {app_1: charm_1, app_2: charm_2}
 
-    expected_relation = check_spaces.Relation("ubuntu:endpoint_1", "nrpe:endpoint_2")
+    expected_relation = spaces.Relation("ubuntu:endpoint_1", "nrpe:endpoint_2")
 
-    mismatch_instance = check_spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
+    mismatch_instance = spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
 
     assert mismatch_instance.get_charm_relation(app_map) == expected_relation
 
@@ -173,32 +173,28 @@ def test_find_space_mismatches(use_cmr, mocker):
     space_2 = "space 2"
     app_endpoint_1 = app_1 + ":endpoint"
     app_endpoint_2 = app_2 + ":endpoint"
-    relation = check_spaces.Relation(
-        app_endpoint_1, "XModel" if use_cmr else app_endpoint_2
-    )
+    relation = spaces.Relation(app_endpoint_1, "XModel" if use_cmr else app_endpoint_2)
     app_list = [app_1, app_2]
     app_spaces = {app_1: {space_1: "foo"}, app_2: {space_2: "bar"}}
 
     app_list_mock = mocker.patch.object(
-        check_spaces, "get_juju_applications", return_value=app_list
+        spaces, "get_juju_applications", return_value=app_list
     )
     app_spaces_mock = mocker.patch.object(
-        check_spaces, "get_application_spaces", return_value=app_spaces
+        spaces, "get_application_spaces", return_value=app_spaces
     )
     rel_list_mock = mocker.patch.object(
-        check_spaces, "get_application_relations", return_value=[relation]
+        spaces, "get_application_relations", return_value=[relation]
     )
     rel_space_mock = mocker.patch.object(
-        check_spaces, "get_relation_space", side_effect=[space_1, space_2]
+        spaces, "get_relation_space", side_effect=[space_1, space_2]
     )
 
     expected_mismatch = [
-        check_spaces.SpaceMismatch(
-            relation.endpoint1, space_1, relation.endpoint2, space_2
-        )
+        spaces.SpaceMismatch(relation.endpoint1, space_1, relation.endpoint2, space_2)
     ]
 
-    mismatch = check_spaces.find_space_mismatches(sample_yaml, True)
+    mismatch = spaces.find_space_mismatches(sample_yaml, True)
     result_pairs = zip(expected_mismatch, mismatch)
 
     app_list_mock.assert_called_once_with(sample_yaml)
@@ -224,7 +220,7 @@ def test_get_juju_applications():
 
     expected_apps = [app_1, app_2]
 
-    apps = check_spaces.get_juju_applications(sample_yaml)
+    apps = spaces.get_juju_applications(sample_yaml)
 
     assert apps == expected_apps
 
@@ -235,7 +231,7 @@ def test_get_application_spaces(mocker):
     This test also verifies that default binding to space "alpha" is added to applications
     that do not specify any bindings.
     """
-    logger_mock = mocker.patch.object(check_spaces, "LOGGER")
+    logger_mock = mocker.patch.object(spaces, "LOGGER")
     default_binding = ""
     default_space = "custom_default_space"
     public_binding = "public"
@@ -269,7 +265,7 @@ def test_get_application_spaces(mocker):
         app_list[2]: {default_binding: "alpha"},
     }
 
-    app_spaces = check_spaces.get_application_spaces(app_list, sample_yaml)
+    app_spaces = spaces.get_application_spaces(app_list, sample_yaml)
 
     # Verify that all the bindings for properly defined app were returned
     # Verify that default binding was added to app that did not have any bindings defined
@@ -298,11 +294,11 @@ def test_get_application_relations():
     }
 
     expected_relations = [
-        check_spaces.Relation("ubuntu:juju-info", "nrpe:general-info"),
-        check_spaces.Relation("vault:shared-db", "mysql-innodb-cluster:shared-db"),
+        spaces.Relation("ubuntu:juju-info", "nrpe:general-info"),
+        spaces.Relation("vault:shared-db", "mysql-innodb-cluster:shared-db"),
     ]
 
-    relations = check_spaces.get_application_relations(sample_yaml)
+    relations = spaces.get_application_relations(sample_yaml)
 
     assert relations == expected_relations
 
@@ -323,21 +319,21 @@ def test_get_relation_space(use_explicit_binding):
     else:
         expected_space = default_space
 
-    space = check_spaces.get_relation_space(endpoint, app_spaces)
+    space = spaces.get_relation_space(endpoint, app_spaces)
 
     assert space == expected_space
 
 
 def test_get_relation_space_cmr(mocker):
     """Test getting space for cross model relation."""
-    logger_mock = mocker.patch.object(check_spaces, "LOGGER")
+    logger_mock = mocker.patch.object(spaces, "LOGGER")
     app_name = "ubuntu"
     interface = "juju_info"
     endpoint = app_name + ":" + interface
 
     app_spaces = {}
 
-    space = check_spaces.get_relation_space(endpoint, app_spaces)
+    space = spaces.get_relation_space(endpoint, app_spaces)
 
     assert space == "XModel"
     logger_mock.warning.assert_called_once_with(
diff --git a/tox.ini b/tox.ini
index 4dea114..08183e2 100644
--- a/tox.ini
+++ b/tox.ini
@@ -23,7 +23,7 @@ deps =
     -r{toxinidir}/requirements.txt
     -r{toxinidir}/tests/unit/requirements.txt
 commands =
-    pytest -v \
+    pytest -vv \
     --cov=jujulint \
     --new-first \
     --last-failed \