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

[Gabriel Cocenza]

added new relation rule check for ubiquitous

- ubiquitous relation rule to ensure every machine has a charm unit on it.

- added ubiquitous relation rule to nrpe, telegraf, filebeat, landscape-client and ubuntu-advantage.

- added a new model input module that is responsible to differentiate the
  type of input (Juju Status, Juju Bundle). The input object encapsulate
  all mapping and queries necessary against a file.

Closes-Bug: #1893272

This change is mainly focused on checking charms that need to be deployed on every machine.

The next step is differentiate container, virtual and physical machines and add adapt to check ntp, hw-health, lldpd just on the physical ones.

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

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

[Gabriel Cocenza (gabrielcocenza)]

logs of unit, lint and functional test [0]

[0] https://pastebin.canonical.com/p/8Vp9Vdv2xQ/

[Martin Kalcok (martin-kalcok)]

Thanks for the improvements. Overall LGTM, but I do have some comments (see inline)

review: Needs Fixing

[Martin Kalcok (martin-kalcok)]

LGTM, thanks.

review: Approve

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

PASSED: Continuous integration, rev:5dc4c256dedc2d5596d00f1c6be6453df5a572a9
https://jenkins.canonical.com/bootstack/job/lp-juju-lint-ci/1/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-unit/302/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1460/

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

review: Approve (continuous-integration)

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

Change successfully merged at revision 9160dae8189345db8494835da2465d9acf8b9d8f

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ef0a32c..2baa385 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -55,9 +55,9 @@ make clean           # clean the snapcraft lxd containers and the snap files cre
 ```
 ### Functional Tests
 
-`make functional` will build the snap, rename it, install it locally and run the tests against the installed snap package. Since this action involves installing a snap package, passwordless `sudo` privileges are needed.  
+`make functional` will build the snap, rename it, install it locally and run the tests against the installed snap package. Since this action involves installing a snap package, passwordless `sudo` privileges are needed.
 However for development purposes, the testing infrastructure also allows for installing `juju-lint` as a python package to a tox environment
-and running tests against it.  
+and running tests against it.
 In order to invoke:
 - development smoke suite, which deselects tests running against a live lxd cloud
   - `$ tox -e func-smoke`
diff --git a/contrib/includes/base.yaml b/contrib/includes/base.yaml
index 2ab4712..8e0a2ce 100644
--- a/contrib/includes/base.yaml
+++ b/contrib/includes/base.yaml
@@ -46,7 +46,22 @@ subordinates:
 
 # openstack and k8s should check nrpe relations. See LP#1965762
 relations base check: &relations-base-check
+  # NOTE(gabrielcocenza) filebeat, telegraf, nrpe are necessary until switch to the COS
   - charm: nrpe
     check: [
       ["*:nrpe-external-master", "nrpe:nrpe-external-master"]
     ]
+    # every machine has nrpe unit on it. See LP#1893272
+    ubiquitous: true
+
+  - charm: telegraf
+    ubiquitous: true
+
+  - charm: filebeat
+    ubiquitous: true
+
+  - charm: landscape-client
+    ubiquitous: true
+
+  - charm: ubuntu-advantage
+    ubiquitous: true
diff --git a/jujulint/lint.py b/jujulint/lint.py
index 937733e..8bbcff4 100755
--- a/jujulint/lint.py
+++ b/jujulint/lint.py
@@ -36,6 +36,7 @@ from dateutil import relativedelta
 import jujulint.util as utils
 from jujulint.check_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")
@@ -613,20 +614,19 @@ class Linter:
             if not self.model.extraneous_subs[sub]:
                 del self.model.extraneous_subs[sub]
 
-    def check_relations(self, applications):
+    def check_relations(self, input_file):
         """Check the relations in the rules file.
 
-        :param applications: applications present in the model
-        :type applications: Dict
+        :param input_file: mapped content of the input file.
+        :type input_file: Union[JujuBundleFile, JujuStatusFile]
         """
         if "relations" not in self.lint_rules:
             self._log_with_header("No relation rules found. Skipping relation checks")
             return
         try:
             relations_rules = RelationsRulesBootStrap(
-                charm_to_app=self.model.charm_to_app,
                 relations_rules=self.lint_rules["relations"],
-                applications=applications,
+                input_file=input_file,
             ).check()
         except RelationError as e:
             relations_rules = []
@@ -656,6 +656,18 @@ class Linter:
                         }
                     )
 
+            if rule.missing_machines:
+                self.handle_error(
+                    {
+                        "id": "missing-machine",
+                        "tags": ["missing", "machine"],
+                        "message": "Charm '{}' missing on machines: {}".format(
+                            rule.charm,
+                            rule.missing_machines,
+                        ),
+                    }
+                )
+
     def check_charms_ops_mandatory(self, charm):
         """
         Check if a mandatory ops charms is present in the model.
@@ -1228,9 +1240,8 @@ class Linter:
     def do_lint(self, parsed_yaml):  # pragma: no cover
         """Lint parsed YAML."""
         # Handle Juju 2 vs Juju 1
-        applications = "applications"
-        if applications not in parsed_yaml:
-            applications = "services"
+        applications = "applications" if "applications" in parsed_yaml else "services"
+        input_file = input_handler(parsed_yaml, applications)
 
         if applications in parsed_yaml:
 
@@ -1251,7 +1262,7 @@ class Linter:
                 self.process_subordinates(parsed_yaml[applications][app], app)
 
             self.check_subs(parsed_yaml["machines"])
-            self.check_relations(parsed_yaml[applications])
+            self.check_relations(input_file)
             self.check_charms()
 
             if "relations" in parsed_yaml:
diff --git a/jujulint/model_input.py b/jujulint/model_input.py
new file mode 100644
index 0000000..a14551c
--- /dev/null
+++ b/jujulint/model_input.py
@@ -0,0 +1,331 @@
+#! /usr/bin/env python3
+from __future__ import annotations  # type annotations are lazy-evaluated
+
+"""Treat input formats to lint."""
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from functools import partialmethod
+from logging import getLogger
+from typing import Any, Dict, List, Set, Tuple, Union
+
+from jujulint.util import extract_charm_name
+
+LOGGER = getLogger(__name__)
+
+
+@dataclass
+class BaseFile:
+    """BaseFile to define common properties and methods."""
+
+    applications_data: Dict
+    machines_data: Dict
+    charms: Set = field(default_factory=set)
+    machines: Set = field(default_factory=set)
+    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))
+
+    def __post_init__(self):
+        """Dunder method to map file after instantiating."""
+        self.map_file()
+
+    @property
+    def applications(self) -> Set:
+        """Applications present in the file."""
+        return set(self.applications_data.keys())
+
+    @staticmethod
+    def split_relation(relation: List[List[str]]) -> Tuple[str, str]:
+        """Split relations into apps and endpoints.
+
+        :param relation: Relation having the following format:
+            [[<app_1>:<endpoint_1>], [<app_2>:<endpoint_2>]]
+        :type relation: List[List[str]]
+        :return: Relation and endpoint.
+        :rtype: Tuple[str, str]
+        """
+        return *relation[0].split(":"), *relation[1].split(":")
+
+    def map_file(self) -> None:
+        """Process the input file."""
+        for app in self.applications:
+            if "charm" in self.applications_data[app]:
+                charm_name = extract_charm_name(self.applications_data[app]["charm"])
+                self.charms.add(charm_name)
+                self.app_to_charm[app] = charm_name
+                self.charm_to_app[charm_name].add(app)
+                self.map_machines()
+                self.map_apps_to_machines()
+
+    def check_app_endpoint_existence(
+        self, app_endpoint: str, charm: str, endpoints_key: str
+    ) -> Tuple[str, str]:
+        """Check if app and endpoint exist on the object to lint.
+
+        :param app_endpoint: app and endpoint separated by ":" with the following format:
+            <app>:<endpoint>. When app is equal to "*", it's considered as ALL possible apps
+        :type app_endpoint: str
+        :param charm: charm to not check itself.
+        :type charm: str
+        :param endpoints_key: dictionary key to access endpoints.
+        :type endpoints_key: str
+        :return: application and endpoint
+        :rtype: Tuple[str, str]
+        """
+        app, endpoint = app_endpoint.split(":")
+        # app == "*" means all apps
+        # a charm from relation rule can have different app names.
+        if app != "*" and app != charm:
+            if app not in self.applications:
+                LOGGER.warning(f"{app} not found on applications.")
+                return "", ""
+
+            # NOTE(gabrielcocenza) it's not always that a bundle will contain all endpoints under "bindings".
+            # See LP#1949883 and LP#1990017
+            # juju-info is represented by "" on endpoint-bindings
+            if endpoint != "juju-info" and endpoint not in self.applications_data[
+                app
+            ].get(endpoints_key, {}):
+                LOGGER.warning(f"endpoint: {endpoint} not found on {app}")
+                return "", ""
+        return app, endpoint
+
+    def filter_by_app_and_endpoint(
+        self, charm: str, app: str, endpoint: str, endpoints_key: str
+    ) -> Set:
+        """Filter applications by the presence of an endpoint.
+
+        :param charm: Charm to not filter itself.
+        :type charm: str
+        :param app: Application to be filtered. When app is equal to "*", filters ALL apps
+            that have the endpoint passed.
+        :type app: str
+        :param endpoint: Endpoint of an application.
+        :type endpoint: str
+        :param endpoints_key: dictionary key to access endpoint.
+        :type endpoints_key: str
+        :return:  Applications that matches with the endpoint passed.
+        :rtype: Set
+        """
+        # when app == "*", filters all apps that have the endpoint passed.
+        if app == "*":
+            #  remove all possible app names to not check itself.
+            apps_to_check = self.applications - self.charm_to_app[charm]
+            return {
+                app
+                for app in apps_to_check
+                if endpoint
+                in self.applications_data.get(app, {}).get(endpoints_key, {})
+            }
+        return (
+            set([app])
+            if endpoint in self.applications_data.get(app, {}).get(endpoints_key, {})
+            else set()
+        )
+
+    def map_machines(self):
+        """Map machines method to be implemented.
+
+        :raises NotImplementedError: Raise if not implemented on child classes.
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} missing: map_machines")
+
+    def map_apps_to_machines(self):
+        """Map apps to machines method to be implemented.
+
+        :raises NotImplementedError: Raise if not implemented on child classes.
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} missing: map_apps_to_machines"
+        )
+
+    def filter_by_relation(self, apps: Set, endpoint: str) -> Set:
+        """Filter apps by relation to be implemented.
+
+        :raises NotImplementedError: Raise if not implemented on child classes.
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} missing: filter_by_relation"
+        )
+
+    def sorted_machines(self, machine: str):
+        """Sort machines.
+
+        :param machine: machine id.
+        :type machine: str
+        :raises NotImplementedError: Raise if not implemented on child classes.
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} missing: sorted_machines")
+
+
+@dataclass
+class JujuStatusFile(BaseFile):
+    """Juju status file input representation."""
+
+    def map_machines(self) -> None:
+        """Map machines passed on the file."""
+        self.machines.update(self.machines_data.keys())
+        for machine in self.machines_data:
+            self.machines.update(self.machines_data[machine].get("containers", []))
+
+    def map_apps_to_machines(self) -> None:
+        """Map applications on machines."""
+        for app in self.applications_data:
+            units = self.applications_data[app].get("units", {})
+            for unit in units:
+                machine = units[unit].get("machine")
+                self.apps_to_machines[app].add(machine)
+                subordinates = units[unit].get("subordinates", {})
+                for sub in subordinates:
+                    self.apps_to_machines[sub.split("/")[0]].add(machine)
+
+    @staticmethod
+    def sorted_machines(machine: str) -> Tuple[int, str, int]:
+        """Sort machines by number and/or containers.
+
+        :param machine: name of the machine
+            E.g of expected input: "1", "1/lxd/3"
+        :type machine: str
+        :return: tuple with sort keys
+        :rtype: Tuple[int, str, int]
+        """
+        # way to be sure that a machine have at least 3 key values to sort
+        key_1, key_2, key_3, *_ = machine.split("/") + ["", 0]
+        return int(key_1), key_2, int(key_3)
+
+    # overwrite parent method passing "endpoint-bindings" as endpoints_key
+    filter_by_app_and_endpoint = partialmethod(
+        BaseFile.filter_by_app_and_endpoint, endpoints_key="endpoint-bindings"
+    )
+    check_app_endpoint_existence = partialmethod(
+        BaseFile.check_app_endpoint_existence, endpoints_key="endpoint-bindings"
+    )
+
+    def filter_by_relation(self, apps: Set, endpoint: str) -> Set:
+        """Filter applications that relate with an endpoint.
+
+        :param apps: Applications to filter relations using the endpoint.
+        :type apps: Set
+        :param endpoint: endpoint of the applications.
+        :type endpoint: str
+        :return: Applications that has a relation with the apps using the endpoint.
+        :rtype: Set
+        """
+        apps_related = set()
+        for app in apps:
+            relations = self.applications_data.get(app, {}).get("relations", {})
+            apps_related.update(relations.get(endpoint, []))
+        return apps_related
+
+
+@dataclass
+class JujuBundleFile(BaseFile):
+    """Juju bundle file input representation."""
+
+    relations_data: List = field(default_factory=list)
+
+    def map_machines(self) -> None:
+        """Map machines passed on the file."""
+        self.machines.update(self.machines_data.keys())
+        for app in self.applications_data:
+            deploy_to_machines = self.applications_data[app].get("to", [])
+            # openstack bundles can have corner cases e.g: to: - designate-bind/0
+            # in this case the application is deployed where designate-bind/0 is located
+            # See https://launchpad.net/bugs/1965256
+            machines = [machine for machine in deploy_to_machines if "/" not in machine]
+            self.machines.update(machines)
+
+    def map_apps_to_machines(self) -> None:
+        """Map applications on machines."""
+        for app in self.applications_data:
+            machines = self.applications_data[app].get("to", [])
+            self.apps_to_machines[app].update(machines)
+        # 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)
+            # 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])
+            elif app_2 in subordinates:
+                self.apps_to_machines[app_2].update(self.apps_to_machines[app_1])
+
+    @staticmethod
+    def sorted_machines(machine: str) -> Tuple[int, str]:
+        """Sort machines by number and/or containers.
+
+        :param machine: name of the machine
+            E.g of expected input: "1", "lxd:1"
+        :type machine: str
+        :return: tuple with sort keys
+        :rtype: Tuple[int, str]
+        """
+        # way to be sure that a machine have at least 2 key values to sort
+        key_1, key_2, *_ = machine.split(":") + [""]
+
+        if key_1.isdigit():
+            # not container machines comes first.
+            return int(key_1), "0"
+        # in a container from a bundle, the machine number it's in the end. E.g: lxd:1
+        else:
+            return int(key_2), key_1
+
+    # overwrite parent method passing "bindings" as endpoints_key
+    filter_by_app_and_endpoint = partialmethod(
+        BaseFile.filter_by_app_and_endpoint, endpoints_key="bindings"
+    )
+    check_app_endpoint_existence = partialmethod(
+        BaseFile.check_app_endpoint_existence, endpoints_key="bindings"
+    )
+
+    def filter_by_relation(self, apps: Set, endpoint: str) -> Set:
+        """Filter applications that relate with an endpoint.
+
+        :param apps: Applications to filter relations using the endpoint.
+        :type apps: Set
+        :param endpoint: endpoint of the applications.
+        :type endpoint: str
+        :return: Applications that has a relation with the apps using the endpoint.
+        :rtype: Set
+        """
+        apps_related = set()
+        for relation in self.relations_data:
+            for app in apps:
+                app_ep = f"{app}:{endpoint}"
+                app_1_ep_1, app_2_ep_2 = relation
+                if app_1_ep_1 == app_ep:
+                    apps_related.add(app_2_ep_2.split(":")[0])
+                elif app_2_ep_2 == app_ep:
+                    apps_related.add(app_1_ep_1.split(":")[0])
+        return apps_related
+
+
+def input_handler(
+    parsed_yaml: Dict[str, Any], applications_key: str
+) -> Union[JujuStatusFile, JujuBundleFile]:
+    """Input handler to set right methods and fields.
+
+    :param parsed_yaml: input file that came from juju status or bundle.
+    :type parsed_yaml: Dict[str, Any]
+    :param applications_key: key to access applications or services (Juju v1)
+    :type applications_key: str
+    :return: Data Class from juju status or bundle.
+    :rtype: Union[JujuStatus, JujuBundle]
+    """
+    # relations key field is present just on bundles
+    if applications_key in parsed_yaml:
+        if "relations" in parsed_yaml:
+            return JujuBundleFile(
+                applications_data=parsed_yaml[applications_key],
+                machines_data=parsed_yaml["machines"],
+                relations_data=parsed_yaml["relations"],
+            )
+        else:
+            return JujuStatusFile(
+                applications_data=parsed_yaml[applications_key],
+                machines_data=parsed_yaml["machines"],
+            )
diff --git a/jujulint/relations.py b/jujulint/relations.py
index b6a39d2..6b85a6e 100644
--- a/jujulint/relations.py
+++ b/jujulint/relations.py
@@ -1,7 +1,9 @@
 #!/usr/bin/python3
 """Checks relations between applications."""
 from logging import getLogger
-from typing import Any, Dict, List, Set, Tuple
+from typing import Any, Dict, List, Set, Union
+
+from jujulint.model_input import JujuBundleFile, JujuStatusFile
 
 LOGGER = getLogger(__name__)
 
@@ -23,46 +25,47 @@ class RelationRule:
 
     def __init__(
         self,
-        charm_to_app: Set,
-        applications: Dict[str, Any],
+        input_file: Union[JujuBundleFile, JujuStatusFile],
         charm: str,
         relations: List[List[str]],
         not_exist: List[List[str]],
         exception: Set,
+        ubiquitous: bool,
     ):
         """Relation Rule object.
 
-        :param charm_to_app: A charm can have more than one application name
-            e.g:(nrpe-host and nrpe-container). This parameters contains all
-            applications name of a given charm.
-        :type charm_to_app: Set
-        :param applications: All applications of the file passed to lint.
-        :type applications: Dict[str, Any]
+        :param input_file: mapped content of the input file.
+        :type input_file: Union[JujuBundleFile, JujuStatusFile]
         :param charm: Name of the charm to check the relations rules.
         :type charm: str
         :param relations: Relations that should be checked of a given charm
             having the following format:
-            [[<application>:<application_endpoint>, <application>:<application_endpoint>]]
+            [[<app_1>:<endpoint_1>], [<app_2>:<endpoint_2>]]
             If <application> == "*" it will check the relation using the endpoint
             on all applications form the file passed.
         :type relations: List[List[str]]
         :param not_exist: Relation that should not exist in the presence of the
             relations passed to be checked. This parameter has the following format:
-            [[<application>:<application_endpoint>, <application>:<application_endpoint>]]
+            [[<app_1>:<endpoint_1>], [<app_2>:<endpoint_2>]]
         :type not_exist: List[List[str]],
         :param exception: Set of applications that the rule doesn't apply to.
         :type exception: Set
+        :param ubiquitous: Check if charm is present on all machines.
+        :type ubiquitous: bool
         """
-        self.charm_to_app = charm_to_app
-        self.applications = applications
+        self.input_file = input_file
         self.charm = charm
         self.relations = relations
         self.not_exist = not_exist
         self.exception = exception
+        self.ubiquitous = ubiquitous
         # remove all possible app names from the subordinate app to not check itself
-        self.apps_to_check = set(self.applications.keys()) - self.charm_to_app
+        # self.apps_to_check = (
+        #     self.input_file.applications - self.input_file.charm_to_app[self.charm]
+        # )
         self.missing_relations = dict()
         self.not_exist_error = list()
+        self.missing_machines = set()
 
     @property
     def relations(self) -> List[List[str]]:
@@ -89,16 +92,26 @@ class RelationRule:
             return
         for relation_rule in raw_relations_rules:
             try:
-                app_0, endpoint_0 = self.check_app_endpoint_existence(relation_rule[0])
-                app_1, endpoint_1 = self.check_app_endpoint_existence(relation_rule[1])
+                app_0, endpoint_0 = self.input_file.check_app_endpoint_existence(
+                    relation_rule[0], self.charm
+                )
+                app_1, endpoint_1 = self.input_file.check_app_endpoint_existence(
+                    relation_rule[1], self.charm
+                )
                 if not all([app_0, endpoint_0, app_1, endpoint_1]):
                     # means that app or endpoint was not found
                     return
-                if app_0 == self.charm:
+                if (
+                    app_0 == self.charm
+                    or app_0 in self.input_file.charm_to_app[self.charm]
+                ):
                     self.endpoint = endpoint_0
                     app_to_check = app_1
                     endpoint_to_check = endpoint_1
-                elif app_1 == self.charm:
+                elif (
+                    app_1 == self.charm
+                    or app_1 in self.input_file.charm_to_app[self.charm]
+                ):
                     self.endpoint = endpoint_1
                     app_to_check = app_0
                     endpoint_to_check = endpoint_0
@@ -111,8 +124,10 @@ class RelationRule:
                     return
 
                 # check if all apps variations has the endpoint
-                for app in self.charm_to_app:
-                    self.check_app_endpoint_existence(f"{app}:{self.endpoint}")
+                for app in self.input_file.charm_to_app[self.charm]:
+                    self.input_file.check_app_endpoint_existence(
+                        f"{app}:{self.endpoint}", self.charm
+                    )
                 self._relations.append([app_to_check, endpoint_to_check])
             except (IndexError, ValueError) as e:
                 raise RelationError(f"Relations rules has an unexpected format: {e}")
@@ -127,71 +142,32 @@ class RelationRule:
 
     def check(self) -> None:
         """Apply the relations rules check."""
-        self.relation_exist_check()
-        self.relation_not_exist_check()
-
-    def filter_by_app_and_endpoint(self, app: str, endpoint: str) -> Set:
-        """Filter applications by the presence of an endpoint.
-
-        :param app: Application to be filtered.
-        :type app: str
-        :param endpoint: Endpoint of a application.
-        :type endpoint: str
-        :return: Applications that matched with the endpoint passed.
-        :rtype: Set
-        """
-        # NOTE(gabrielcocenza) this function just works with fields from juju status.
-        # when app == "*", filters all apps that have the endpoint passed.
-        if app == "*":
-            return {
-                app
-                for app in self.apps_to_check
-                if endpoint
-                in self.applications.get(app, {}).get("endpoint-bindings", {})
-            }
-        return (
-            set([app])
-            if endpoint in self.applications.get(app, {}).get("endpoint-bindings", {})
-            else set()
-        )
-
-    def filter_by_relation(self, apps: Set, endpoint: str) -> Set:
-        """Filter applications that relate with an endpoint.
-
-        :param apps: Applications to filter relations using the endpoint.
-        :type apps: Set
-        :param endpoint: endpoint of the applications.
-        :type endpoint: str
-        :return: Applications that has a relation with the apps using the endpoint.
-        :rtype: Set
-        """
-        # NOTE(gabrielcocenza) this function just works with fields from juju status.
-        apps_related = set()
-        for app in apps:
-            relations = self.applications.get(app, {}).get("relations", {})
-            apps_related.update(relations.get(endpoint, []))
-        return apps_related
+        try:
+            self.missing_machines = self.ubiquitous_check()
+            self.relation_exist_check()
+            self.relation_not_exist_check()
+        except NotImplementedError as e:
+            LOGGER.debug(e)
 
     def relation_exist_check(self) -> None:
         """Check if app(s) are relating with an endpoint."""
         for relation in self.relations:
             app_to_check, endpoint_to_check = relation
             # applications in the bundle that have the endpoint to relate
-            apps_with_endpoint_to_check = self.filter_by_app_and_endpoint(
+            apps_with_endpoint_to_check = self.input_file.filter_by_app_and_endpoint(
+                self.charm,
                 app_to_check,
                 endpoint_to_check,
             )
             # applications that are relating using the endpoint from the relation rule
-            apps_related_with_relation_rule = self.filter_by_relation(
-                self.charm_to_app,
+            apps_related_with_relation_rule = self.input_file.filter_by_relation(
+                self.input_file.charm_to_app[self.charm],
                 self.endpoint,
             )
             self.missing_relations[f"{self.charm}:{self.endpoint}"] = sorted(
-                list(
-                    apps_with_endpoint_to_check
-                    - apps_related_with_relation_rule
-                    - self.exception
-                )
+                apps_with_endpoint_to_check
+                - apps_related_with_relation_rule
+                - self.exception
             )
 
     def relation_not_exist_check(self) -> None:
@@ -204,7 +180,9 @@ class RelationRule:
                 app_endpoint_splitted = []
                 try:
                     for app_endpoint in relation:
-                        app, endpoint = self.check_app_endpoint_existence(app_endpoint)
+                        app, endpoint = self.input_file.check_app_endpoint_existence(
+                            app_endpoint, self.charm
+                        )
                         app_endpoint_splitted.extend([app, endpoint])
                     (
                         app_to_check_0,
@@ -212,7 +190,7 @@ class RelationRule:
                         app_to_check_1,
                         _,
                     ) = app_endpoint_splitted
-                    relations_app_endpoint_0 = self.filter_by_relation(
+                    relations_app_endpoint_0 = self.input_file.filter_by_relation(
                         {app_to_check_0}, endpoint_to_check_0
                     )
                     if app_to_check_1 in relations_app_endpoint_0:
@@ -221,32 +199,23 @@ class RelationRule:
                 except (IndexError, ValueError) as e:
                     raise RelationError(f"Problem during check_relation_not_exist: {e}")
 
-    def check_app_endpoint_existence(self, app_endpoint: str) -> Tuple[str, str]:
-        """Check if app and endpoint exist on the object to lint.
+    def ubiquitous_check(self) -> List[str]:
+        """Check if charm from relation rule is present on all machines.
 
-        :param app_endpoint: app and endpoint separated by ":" with the following format:
-            <application>:<application_endpoint>
-        :type app_endpoint: str
-        :return: application and endpoint
-        :rtype: Tuple[str, str]
+        :return: Sorted list of machines missing the charm. If is present on
+            all machines, returns an empty list.
+        :rtype: List[str]
         """
-        app, endpoint = app_endpoint.split(":")
-        # app == "*" means all apps
-        # a charm from relation rule can have different app names.
-        if app != "*" and app != self.charm:
-            if app not in self.applications.keys():
-                LOGGER.warning(f"{app} not found on applications to check relations")
-                return "", ""
-
-            # juju-info is represented by "" on endpoint-bindings
-            if endpoint != "juju-info" and endpoint not in self.applications[app].get(
-                "endpoint-bindings", {}
-            ):
-                LOGGER.warning(
-                    f"{app} don't have the endpoint: {endpoint} to check relations"
-                )
-                return "", ""
-        return app, endpoint
+        if self.ubiquitous:
+            machines_with_charm = set()
+            for app in self.input_file.charm_to_app[self.charm]:
+                machines_with_charm.update(self.input_file.apps_to_machines[app])
+
+            return sorted(
+                self.input_file.machines - machines_with_charm,
+                key=self.input_file.sorted_machines,
+            )
+        return []
 
 
 class RelationsRulesBootStrap:
@@ -254,24 +223,18 @@ class RelationsRulesBootStrap:
 
     def __init__(
         self,
-        charm_to_app: Dict[str, Set],
         relations_rules: List[Dict[str, Any]],
-        applications: Dict[str, Any],
+        input_file: Union[JujuBundleFile, JujuStatusFile],
     ):
         """Relations rules bootStrap object.
 
-        :param charm_to_app: A charm can have more than one application name
-            e.g:(nrpe-host and nrpe-container). This parameters contains all
-            applications name of a given charm.
-        :type charm_to_app: Dict[str, Set]
         :param relations_rules: Relations rules from the rule file.
         :type relations_rules: List[Dict[str, Any]]
-        :param applications: All applications of the file passed to lint.
-        :type applications: Dict[str, Any]
+        :param input_file: mapped content of the input file.
+        :type input_file: Union[JujuBundleFile, JujuStatusFile]
         """
-        self.charm_to_app = charm_to_app
         self.relations_rules = relations_rules
-        self.applications = applications
+        self.input_file = input_file
 
     def check(self) -> List[RelationRule]:
         """Check all RelationRule objects.
@@ -281,12 +244,12 @@ class RelationsRulesBootStrap:
         """
         relations_rules = [
             RelationRule(
-                charm_to_app=self.charm_to_app.get(rule.get("charm", ""), set()),
-                applications=self.applications,
+                input_file=self.input_file,
                 charm=rule.get("charm"),
                 relations=rule.get("check", [[]]),
                 not_exist=rule.get("not-exist", [[]]),
                 exception=set(rule.get("exception", set())),
+                ubiquitous=rule.get("ubiquitous", False),
             )
             for rule in self.relations_rules
         ]
diff --git a/setup.py b/setup.py
index 9314d60..9bd497c 100644
--- a/setup.py
+++ b/setup.py
@@ -41,7 +41,7 @@ setuptools.setup(
         "Environment :: Plugins",
         "Intended Audience :: System Administrators",
     ],
-    python_requires=">=3.4",
+    python_requires=">=3.7",
     packages=["jujulint"],
     entry_points={"console_scripts": ["juju-lint=jujulint.cli:main"]},
     setup_requires=["setuptools_scm"],
diff --git a/tests/unit/conftest.py b/tests/unit/conftest.py
index 00500ea..b49a4b2 100644
--- a/tests/unit/conftest.py
+++ b/tests/unit/conftest.py
@@ -16,12 +16,13 @@ from unittest.mock import MagicMock
 import mock
 import pytest
 
+from jujulint import cloud  # noqa: E402
+from jujulint.model_input import JujuBundleFile, JujuStatusFile
+
 # bring in top level library to path
 test_path = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, test_path + "/../")
 
-from jujulint import cloud  # noqa: E402
-
 
 @pytest.fixture
 def mocked_pkg_resources(monkeypatch):
@@ -130,6 +131,7 @@ def juju_status():
                 "charm": "cs:ntp-47",
                 "charm-name": "ntp",
                 "relations": {"juju-info": ["ubuntu"]},
+                "subordinate-to": ["ubuntu"],
                 "endpoint-bindings": {
                     "": "external-space",
                     "certificates": "external-space",
@@ -240,82 +242,237 @@ def rules_files():
 
 
 @pytest.fixture
-def juju_status_relation():
+def input_files(parsed_yaml_status, parsed_yaml_bundle):
+    return {
+        "juju-status": JujuStatusFile(
+            applications_data=parsed_yaml_status["applications"],
+            machines_data=parsed_yaml_status["machines"],
+        ),
+        "juju-bundle": JujuBundleFile(
+            applications_data=parsed_yaml_bundle["applications"],
+            machines_data=parsed_yaml_bundle["machines"],
+            relations_data=parsed_yaml_bundle["relations"],
+        ),
+    }
+
+
[e-mail]
+def parsed_yaml_status():
     """Representation of juju status input to test relations checks."""
     return {
-        "nrpe-container": {
-            "charm": "cs:nrpe-61",
-            "charm-name": "nrpe",
-            "relations": {
-                "monitors": ["nagios"],
-                "nrpe-external-master": [
-                    "keystone",
-                ],
+        "applications": {
+            "nrpe-container": {
+                "charm": "cs:nrpe-61",
+                "charm-name": "nrpe",
+                "relations": {
+                    "nrpe-external-master": [
+                        "keystone",
+                    ],
+                },
+                "endpoint-bindings": {
+                    "general-info": "",
+                    "local-monitors": "",
+                    "monitors": "oam-space",
+                    "nrpe": "",
+                    "nrpe-external-master": "",
+                },
+                "subordinate-to": ["keystone"],
             },
-            "endpoint-bindings": {
-                "general-info": "",
-                "local-monitors": "",
-                "monitors": "oam-space",
-                "nrpe": "",
-                "nrpe-external-master": "",
+            "nrpe-host": {
+                "charm": "cs:nrpe-67",
+                "charm-name": "nrpe",
+                "relations": {
+                    "nrpe-external-master": [
+                        "elasticsearch",
+                    ],
+                    "general-info": ["ubuntu"],
+                },
+                "endpoint-bindings": {
+                    "general-info": "",
+                    "local-monitors": "",
+                    "monitors": "oam-space",
+                    "nrpe": "",
+                    "nrpe-external-master": "",
+                },
+                "subordinate-to": ["elasticsearch", "ubuntu"],
             },
-        },
-        "nrpe-host": {
-            "charm": "cs:nrpe-67",
-            "charm-name": "nrpe",
-            "relations": {
-                "monitors": ["nagios"],
-                "nrpe-external-master": [
-                    "elasticsearch",
-                ],
+            "ubuntu": {
+                "application-status": {"current": "active"},
+                "charm": "cs:ubuntu-18",
+                "charm-name": "ubuntu",
+                "relations": {"juju-info": ["nrpe-host"]},
+                "endpoint-bindings": {
+                    "": "external-space",
+                    "certificates": "external-space",
+                },
+                "units": {
+                    "ubuntu/0": {
+                        "machine": "1",
+                        "workload-status": {"current": "active"},
+                        "subordinates": {
+                            "nrpe-host/0": {
+                                "workload-status": {
+                                    "current": "active",
+                                }
+                            }
+                        },
+                    }
+                },
             },
-            "endpoint-bindings": {
-                "general-info": "",
-                "local-monitors": "",
-                "monitors": "oam-space",
-                "nrpe": "",
-                "nrpe-external-master": "",
+            "keystone": {
+                "charm": "cs:keystone-309",
+                "charm-name": "keystone",
+                "relations": {
+                    "nrpe-external-master": ["nrpe-container"],
+                },
+                "endpoint-bindings": {
+                    "": "oam-space",
+                    "admin": "external-space",
+                    "certificates": "oam-space",
+                    "cluster": "oam-space",
+                    "domain-backend": "oam-space",
+                    "ha": "oam-space",
+                    "identity-admin": "oam-space",
+                    "identity-credentials": "oam-space",
+                    "identity-notifications": "oam-space",
+                    "identity-service": "oam-space",
+                    "internal": "internal-space",
+                    "keystone-fid-service-provider": "oam-space",
+                    "keystone-middleware": "oam-space",
+                    "nrpe-external-master": "oam-space",
+                    "public": "external-space",
+                    "shared-db": "internal-space",
+                    "websso-trusted-dashboard": "oam-space",
+                },
+                "units": {
+                    "keystone/0": {
+                        "machine": "1/lxd/0",
+                        "subordinates": {
+                            "nrpe-container/0": {
+                                "workload-status": {
+                                    "current": "active",
+                                }
+                            }
+                        },
+                    }
+                },
+            },
+            "elasticsearch": {
+                "charm": "cs:elasticsearch-39",
+                "charm-name": "elasticsearch",
+                "relations": {
+                    "nrpe-external-master": ["nrpe-host"],
+                },
+                "endpoint-bindings": {
+                    "": "oam-space",
+                    "client": "oam-space",
+                    "data": "oam-space",
+                    "logs": "oam-space",
+                    "nrpe-external-master": "oam-space",
+                    "peer": "oam-space",
+                },
+                "units": {
+                    "elasticsearch/0": {
+                        "machine": "0",
+                        "subordinates": {
+                            "nrpe-host/0": {
+                                "workload-status": {
+                                    "current": "active",
+                                }
+                            }
+                        },
+                    }
+                },
             },
         },
-        "keystone": {
-            "charm": "cs:keystone-309",
-            "charm-name": "keystone",
-            "relations": {
-                "nrpe-external-master": ["nrpe-container"],
+        "machines": {
+            "0": {
+                "series": "focal",
             },
-            "endpoint-bindings": {
-                "": "oam-space",
-                "admin": "external-space",
-                "certificates": "oam-space",
-                "cluster": "oam-space",
-                "domain-backend": "oam-space",
-                "ha": "oam-space",
-                "identity-admin": "oam-space",
-                "identity-credentials": "oam-space",
-                "identity-notifications": "oam-space",
-                "identity-service": "oam-space",
-                "internal": "internal-space",
-                "keystone-fid-service-provider": "oam-space",
-                "keystone-middleware": "oam-space",
-                "nrpe-external-master": "oam-space",
-                "public": "external-space",
-                "shared-db": "internal-space",
-                "websso-trusted-dashboard": "oam-space",
+            "1": {
+                "series": "focal",
+                "containers": {
+                    "1/lxd/0": {
+                        "series": "focal",
+                    }
+                },
             },
         },
-        "elasticsearch": {
-            "charm": "cs:elasticsearch-39",
-            "charm-name": "elasticsearch",
-            "relations": {
-                "nrpe-external-master": ["nrpe-host"],
+    }
+
+
[e-mail]
+def parsed_yaml_bundle():
+    """Representation of juju bundle input to test relations checks."""
+    return {
+        "series": "focal",
+        "applications": {
+            "elasticsearch": {
+                "bindings": {
+                    "nrpe-external-master": "internal-space",
+                },
+                "charm": "elasticsearch",
+                "channel": "stable",
+                "revision": 59,
+                "num_units": 1,
+                "to": ["0"],
+                "constraints": "arch=amd64 mem=4096",
             },
-            "endpoint-bindings": {
-                "": "oam-space",
-                "client": "oam-space",
-                "data": "oam-space",
-                "logs": "oam-space",
-                "nrpe-external-master": "oam-space",
-                "peer": "oam-space",
+            "keystone": {
+                "bindings": {
+                    "nrpe-external-master": "internal-space",
+                    "public": "internal-space",
+                },
+                "charm": "keystone",
+                "channel": "stable",
+                "revision": 539,
+                "resources": {"policyd-override": 0},
+                "num_units": 1,
+                "to": ["lxd:1"],
+                "constraints": "arch=amd64",
+            },
+            "nrpe-container": {
+                "bindings": {
+                    "nrpe-external-master": "internal-space",
+                    "local-monitors": "",
+                },
+                "charm": "nrpe",
+                "channel": "stable",
+                "revision": 94,
+            },
+            "nrpe-host": {
+                "bindings": {
+                    "nrpe-external-master": "internal-space",
+                    "local-monitors": "",
+                },
+                "charm": "nrpe",
+                "channel": "stable",
+                "revision": 94,
+            },
+            "ubuntu": {
+                "bindings": {"": "internal-space", "certificates": "external-space"},
+                "charm": "ubuntu",
+                "channel": "stable",
+                "revision": 21,
+                "num_units": 1,
+                "to": ["1"],
+                "options": {"hostname": ""},
+                "constraints": "arch=amd64 mem=4096",
             },
         },
+        "machines": {
+            "0": {"constraints": "arch=amd64 mem=4096"},
+            "1": {"constraints": "arch=amd64 mem=4096"},
+        },
+        "relations": [
+            [
+                "nrpe-container:nrpe-external-master",
+                "keystone:nrpe-external-master",
+            ],
+            ["nrpe-host:general-info", "ubuntu:juju-info"],
+            [
+                "elasticsearch:nrpe-external-master",
+                "nrpe-host:nrpe-external-master",
+            ],
+        ],
     }
diff --git a/tests/unit/test_input.py b/tests/unit/test_input.py
new file mode 100644
index 0000000..682b664
--- /dev/null
+++ b/tests/unit/test_input.py
@@ -0,0 +1,233 @@
+from dataclasses import dataclass
+
+import pytest
+
+from jujulint import model_input
+
+
[e-mail]("input_file_type", ["juju-status", "juju-bundle"])
+def test_file_inputs(input_files, input_file_type):
+    """Test that files are mapping properties as expected."""
+    input_file = input_files[input_file_type]
+    expected_output = {
+        "applications": {
+            "elasticsearch",
+            "ubuntu",
+            "keystone",
+            "nrpe-container",
+            "nrpe-host",
+        },
+        "machines": {
+            "juju-status": {"0", "1", "1/lxd/0"},
+            "juju-bundle": {"0", "1", "lxd:1"},
+        },
+        "charms": {"elasticsearch", "ubuntu", "nrpe", "keystone"},
+        "app_to_charm": {
+            "elasticsearch": "elasticsearch",
+            "ubuntu": "ubuntu",
+            "keystone": "keystone",
+            "nrpe-host": "nrpe",
+            "nrpe-container": "nrpe",
+        },
+        "charm_to_app": {
+            "nrpe": {"nrpe-container", "nrpe-host"},
+            "ubuntu": {"ubuntu"},
+            "elasticsearch": {"elasticsearch"},
+            "keystone": {"keystone"},
+        },
+        "apps_to_machines": {
+            "juju-status": {
+                "nrpe-container": {"1/lxd/0"},
+                "nrpe-host": {"0", "1"},
+                "ubuntu": {"1"},
+                "elasticsearch": {"0"},
+                "keystone": {"1/lxd/0"},
+            },
+            "juju-bundle": {
+                "nrpe-container": {"lxd:1"},
+                "nrpe-host": {"0", "1"},
+                "ubuntu": {"1"},
+                "elasticsearch": {"0"},
+                "keystone": {"lxd:1"},
+            },
+        },
+    }
+    assert input_file.applications == expected_output["applications"]
+    assert input_file.machines == expected_output["machines"][input_file_type]
+    assert (
+        input_file.apps_to_machines
+        == expected_output["apps_to_machines"][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"]
+
+
[e-mail](
+    "app_endpoint, app_error, endpoint_error, input_file_type, expected_output",
+    [
+        # app doesn't exist
+        ("foo:juju-info", True, False, "juju-status", ("", "")),
+        ("foo:juju-info", True, False, "juju-bundle", ("", "")),
+        # endpoint doesn't exist
+        ("keystone:bar", False, True, "juju-status", ("", "")),
+        ("keystone:bar", False, True, "juju-bundle", ("", "")),
+        # app and endpoint exist
+        (
+            "keystone:nrpe-external-master",
+            False,
+            False,
+            "juju-status",
+            ("keystone", "nrpe-external-master"),
+        ),
+        (
+            "keystone:nrpe-external-master",
+            False,
+            False,
+            "juju-bundle",
+            ("keystone", "nrpe-external-master"),
+        ),
+    ],
+)
+def test_check_app_endpoint_existence(
+    app_endpoint,
+    app_error,
+    endpoint_error,
+    mocker,
+    input_files,
+    input_file_type,
+    expected_output,
+):
+    """Test the expected check_app_endpoint_existence method behavior."""
+    input_file = input_files[input_file_type]
+    logger_mock = mocker.patch.object(model_input, "LOGGER")
+    app, endpoint = app_endpoint.split(":")
+    expected_msg = ""
+    if app_error:
+        expected_msg = f"{app} not found on applications."
+    elif endpoint_error:
+        expected_msg = f"endpoint: {endpoint} not found on {app}"
+
+    assert (
+        input_file.check_app_endpoint_existence(app_endpoint, "nrpe") == expected_output
+    )
+    if expected_msg:
+        logger_mock.warning.assert_has_calls([mocker.call(expected_msg)])
+
+
[e-mail](
+    "input_file_type, charm, app, endpoint, expected_output",
+    [
+        (
+            "juju-status",
+            "nrpe",
+            "*",
+            "nrpe-external-master",
+            {"keystone", "elasticsearch"},
+        ),  # all apps with nrpe-external-master
+        (
+            "juju-bundle",
+            "nrpe",
+            "*",
+            "nrpe-external-master",
+            {"keystone", "elasticsearch"},
+        ),  # all apps with nrpe-external-master
+        (
+            "juju-status",
+            "nrpe",
+            "keystone",
+            "nrpe-external-master",
+            {"keystone"},
+        ),  # check if keystone has nrpe-external-master
+        (
+            "juju-bundle",
+            "nrpe",
+            "keystone",
+            "nrpe-external-master",
+            {"keystone"},
+        ),  # check if keystone has nrpe-external-master
+        (
+            "juju-status",
+            "nrpe",
+            "ubuntu",
+            "nrpe-external-master",
+            set(),
+        ),  # check if ubuntu has nrpe-external-master
+        (
+            "juju-bundle",
+            "nrpe",
+            "ubuntu",
+            "nrpe-external-master",
+            set(),
+        ),  # check if ubuntu has nrpe-external-master
+    ],
+)
+def test_filter_by_app_and_endpoint(
+    input_files, input_file_type, charm, app, endpoint, expected_output
+):
+    """Test filter_by_app_and_endpoint method behave as expected."""
+    input_file = input_files[input_file_type]
+    assert (
+        input_file.filter_by_app_and_endpoint(charm, app, endpoint) == expected_output
+    )
+
+
[e-mail](
+    "input_file_type, endpoint, expected_output",
+    [
+        ("juju-status", "nrpe-external-master", {"keystone", "elasticsearch"}),
+        ("juju-bundle", "nrpe-external-master", {"keystone", "elasticsearch"}),
+        ("juju-status", "general-info", {"ubuntu"}),
+        ("juju-bundle", "general-info", {"ubuntu"}),
+        ("juju-status", "monitors", set()),
+        ("juju-bundle", "monitors", set()),
+    ],
+)
+def test_filter_by_relation(input_file_type, endpoint, expected_output, input_files):
+    """Test filter_by_relation method behave as expected."""
+    input_file = input_files[input_file_type]
+    assert (
+        input_file.filter_by_relation(input_file.charm_to_app["nrpe"], endpoint)
+        == expected_output
+    )
+
+
[e-mail](
+    "parsed_yaml, expected_output",
+    [
+        ("parsed_yaml_status", model_input.JujuStatusFile),
+        ("parsed_yaml_bundle", model_input.JujuBundleFile),
+    ],
+)
+def test_input_handler(parsed_yaml, expected_output, request):
+    """Input handler return expected objects depending on the input."""
+    input_file = request.getfixturevalue(parsed_yaml)
+    assert isinstance(
+        model_input.input_handler(input_file, "applications"), expected_output
+    )
+
+
+def test_raise_not_implemented_methods(parsed_yaml_status):
+    # declare a new input class
+    @dataclass
+    class MyNewInput(model_input.BaseFile):
+        # overwrite parent method to map file
+        def __post_init__(self):
+            return 0
+
+    new_input = MyNewInput(
+        applications_data=parsed_yaml_status["applications"],
+        machines_data=parsed_yaml_status["machines"],
+    )
+
+    with pytest.raises(NotImplementedError):
+        new_input.map_machines()
+
+    with pytest.raises(NotImplementedError):
+        new_input.map_apps_to_machines()
+
+    with pytest.raises(NotImplementedError):
+        new_input.filter_by_relation({"nrpe"}, "nrpe-external-master")
+
+    with pytest.raises(NotImplementedError):
+        new_input.sorted_machines("0")
diff --git a/tests/unit/test_jujulint.py b/tests/unit/test_jujulint.py
index 136044b..264b15e 100644
--- a/tests/unit/test_jujulint.py
+++ b/tests/unit/test_jujulint.py
@@ -1233,22 +1233,35 @@ applications:
         """Test conversion of string values (e.g. 2M (Megabytes)) to integers."""
         assert linter.atoi(input_str) == expected_int
 
-    def test_check_relations_no_rules(self, linter, juju_status, mocker):
+    @pytest.mark.parametrize("input_file_type", ["juju-status", "juju-bundle"])
+    def test_check_relations_no_rules(
+        self, linter, input_files, mocker, input_file_type
+    ):
         """Warn message if rule file doesn't pass relations to check."""
         mock_log = mocker.patch("jujulint.lint.Linter._log_with_header")
-        linter.check_relations(juju_status["applications"])
+        linter.check_relations(input_files[input_file_type])
         mock_log.assert_called_with("No relation rules found. Skipping relation checks")
 
-    def test_check_relations(self, linter, juju_status, mocker):
+    @pytest.mark.parametrize("input_file_type", ["juju-status", "juju-bundle"])
+    def test_check_relations(self, linter, input_files, mocker, input_file_type):
         """Ensure that check_relation pass."""
         mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
         linter.lint_rules["relations"] = [
-            {"charm": "ntp", "check": [["ntp:juju-info", "ubuntu:juju-info"]]}
+            {"charm": "nrpe", "check": [["nrpe:juju-info", "ubuntu:juju-info"]]}
         ]
-        linter.check_relations(juju_status["applications"])
+        linter.check_relations(input_files[input_file_type])
         mock_handle_error.assert_not_called()
 
-    def test_check_relations_exception_handling(self, linter, juju_status, mocker):
+    @pytest.mark.parametrize(
+        "input_file_type",
+        [
+            "juju-status",
+            "juju-bundle",
+        ],
+    )
+    def test_check_relations_exception_handling(
+        self, linter, juju_status, mocker, input_file_type, input_files
+    ):
         """Ensure that handle error if relation rules are in wrong format."""
         mock_log = mocker.patch("jujulint.lint.Linter._log_with_header")
         mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
@@ -1260,44 +1273,88 @@ applications:
             "values to unpack (expected 2, got 1)"
         )
         expected_exception = relations.RelationError(expected_msg)
-        linter.check_relations(juju_status["applications"])
+
+        linter.check_relations(input_files[input_file_type])
         mock_handle_error.assert_not_called()
         mock_log.assert_has_calls(
             [mocker.call(expected_exception.message, level=logging.ERROR)]
         )
 
-    def test_check_relations_missing_relations(self, linter, juju_status, mocker):
+    @pytest.mark.parametrize("input_file_type", ["juju-status", "juju-bundle"])
+    def test_check_relations_missing_relations(
+        self, linter, juju_status, mocker, input_file_type, input_files
+    ):
         """Ensure that check_relation handle missing relations."""
         mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
         # add a relation rule that doesn't happen in the model
         linter.lint_rules["relations"] = [
-            {"charm": "ntp", "check": [["ntp:certificates", "ubuntu:certificates"]]}
+            {
+                "charm": "nrpe",
+                "check": [["nrpe-host:local-monitors", "ubuntu:certificates"]],
+            }
         ]
-        linter.check_relations(juju_status["applications"])
+        linter.check_relations(input_files[input_file_type])
         mock_handle_error.assert_called_with(
             {
                 "id": "missing-relations",
                 "tags": ["relation", "missing"],
                 "message": "Endpoint '{}' is missing relations with: {}".format(
-                    "ntp:certificates", ["ubuntu"]
+                    "nrpe:local-monitors", ["ubuntu"]
                 ),
             }
         )
 
-    def test_check_relations_exist(self, linter, juju_status, mocker):
+    @pytest.mark.parametrize("input_file_type", ["juju-status", "juju-bundle"])
+    def test_check_relations_exist(self, linter, input_files, mocker, input_file_type):
         """Ensure that check_relation handle not exist error."""
         mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
+        not_exist_relation = [
+            "nrpe-host:nrpe-external-master",
+            "elasticsearch:nrpe-external-master",
+        ]
         # add a relation rule that happen in the model
         linter.lint_rules["relations"] = [
-            {"charm": "ntp", "not-exist": [["ntp:juju-info", "ubuntu:juju-info"]]}
+            {"charm": "nrpe", "not-exist": [not_exist_relation]}
         ]
-        linter.check_relations(juju_status["applications"])
+        linter.check_relations(input_files[input_file_type])
         mock_handle_error.assert_called_with(
             {
                 "id": "relation-exist",
                 "tags": ["relation", "exist"],
                 "message": "Relation(s) {} should not exist.".format(
-                    ["ntp:juju-info", "ubuntu:juju-info"]
+                    not_exist_relation
+                ),
+            }
+        )
+
+    @pytest.mark.parametrize("input_file_type", ["juju-status", "juju-bundle"])
+    def test_check_relations_missing_machine(
+        self, linter, input_files, mocker, input_file_type
+    ):
+        """Ensure that check_relation handle missing machines when ubiquitous."""
+        new_machines = {"3": {"series": "focal"}, "2": {"series": "bionic"}}
+        input_file = input_files[input_file_type]
+        # add two new machines
+        input_file.machines_data.update(new_machines)
+        # map file again
+        input_file.map_file()
+        mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
+        linter.lint_rules["relations"] = [
+            {
+                "charm": "nrpe",
+                "ubiquitous": True,
+            }
+        ]
+
+        expected_missing_machines = ["2", "3"]
+        linter.check_relations(input_file)
+        mock_handle_error.assert_called_with(
+            {
+                "id": "missing-machine",
+                "tags": ["missing", "machine"],
+                "message": "Charm '{}' missing on machines: {}".format(
+                    "nrpe",
+                    expected_missing_machines,
                 ),
             }
         )
diff --git a/tests/unit/test_relations.py b/tests/unit/test_relations.py
index 9ec5d72..f13d544 100644
--- a/tests/unit/test_relations.py
+++ b/tests/unit/test_relations.py
@@ -11,127 +11,191 @@ RELATIONS = [["*:nrpe-external-master", "nrpe:nrpe-external-master"]]
 
 
 @pytest.mark.parametrize(
-    "correct_relation",
+    "correct_relation, input_file_type",
     [
-        RELATIONS,
-        [
-            ["nrpe:nrpe-external-master", "*:nrpe-external-master"]
-        ],  # inverting sequence doesn't change the endpoint
-        [
-            ["nrpe:nrpe-external-master", "keystone:nrpe-external-master"]
-        ],  # able to find specific app relation
+        (RELATIONS, "juju-status"),
+        (RELATIONS, "juju-bundle"),
+        (
+            [["nrpe:nrpe-external-master", "*:nrpe-external-master"]],
+            "juju-status",
+        ),  # inverting sequence doesn't change the endpoint
+        (
+            [["nrpe:nrpe-external-master", "*:nrpe-external-master"]],
+            "juju-bundle",
+        ),  # inverting sequence doesn't change the endpoint
+        (
+            [["nrpe:nrpe-external-master", "keystone:nrpe-external-master"]],
+            "juju-status",
+        ),  # able to find specific app relation
+        (
+            [["nrpe:nrpe-external-master", "keystone:nrpe-external-master"]],
+            "juju-bundle",
+        ),  # able to find specific app relation
     ],
 )
-def test_relation_rule_valid(correct_relation, juju_status_relation):
+def test_relation_rule_valid(correct_relation, input_file_type, input_files):
     """Missing rules have empty set for endpoints with expected relations."""
     relation_rule = relations.RelationRule(
-        charm_to_app=CHARM_TO_APP,
-        applications=juju_status_relation,
+        input_file=input_files[input_file_type],
         charm=CHARM,
         relations=correct_relation,
         not_exist=[[]],
         exception=set(),
+        ubiquitous=True,
     )
     relation_rule.check()
     assert relation_rule.missing_relations == {"nrpe:nrpe-external-master": list()}
     assert relation_rule.not_exist_error == list()
+    assert relation_rule.missing_machines == list()
     assert relation_rule.__repr__() == "RelationRule(nrpe -> nrpe-external-master)"
     assert relation_rule.endpoint == "nrpe-external-master"
 
 
-def test_relation_not_exist(juju_status_relation):
[e-mail]("input_file_type", ["juju-status", "juju-bundle"])
+def test_relation_not_exist(input_file_type, input_files):
     """Ensure that finds a relation that shouldn't happen."""
-    juju_status_relation["foo-charm"] = {
-        "charm": "cs:foo-charm-7",
-        "charm-name": "foo-charm",
-        "relations": {
-            "foo-endpoint": ["keystone"],
-        },
-        "endpoint-bindings": {
-            "": "oam-space",
-            "foo-endpoint": "oam-space",
-        },
-    }
-    juju_status_relation["keystone"]["relations"]["foo-endpoint"] = ["foo-charm"]
-    juju_status_relation["keystone"]["endpoint-bindings"]["foo-endpoint"] = "oam-space"
+    wrong_relation = ["keystone:foo-endpoint", "foo-charm:foo-endpoint"]
+    input_file = input_files[input_file_type]
+    if input_file_type == "juju-status":
+        input_file.applications_data["foo-charm"] = {
+            "charm": "cs:foo-charm-7",
+            "charm-name": "foo-charm",
+            "relations": {
+                "foo-endpoint": ["keystone"],
+            },
+            "endpoint-bindings": {
+                "": "oam-space",
+                "foo-endpoint": "oam-space",
+            },
+        }
+        input_file.applications_data["keystone"]["relations"]["foo-endpoint"] = [
+            "foo-charm"
+        ]
+        input_file.applications_data["keystone"]["endpoint-bindings"][
+            "foo-endpoint"
+        ] = "oam-space"
+
+    elif input_file_type == "juju-bundle":
+        input_file.applications_data["foo-charm"] = {
+            "charm": "cs:foo-charm-7",
+            "charm-name": "foo-charm",
+            "bindings": {
+                "": "oam-space",
+                "foo-endpoint": "oam-space",
+            },
+        }
+        input_file.applications_data["keystone"]["bindings"][
+            "foo-endpoint"
+        ] = "oam-space"
+        input_file.relations_data.append(wrong_relation)
+
     relation_rule = relations.RelationRule(
-        charm_to_app=CHARM_TO_APP,
-        applications=juju_status_relation,
+        input_file=input_file,
         charm=CHARM,
         relations=RELATIONS,
-        not_exist=[["keystone:foo-endpoint", "foo-charm:foo-endpoint"]],
+        not_exist=[wrong_relation],
         exception=set(),
+        ubiquitous=True,
     )
     relation_rule.check()
-    assert relation_rule.not_exist_error == [
-        ["keystone:foo-endpoint", "foo-charm:foo-endpoint"]
-    ]
+    assert relation_rule.not_exist_error == [wrong_relation]
 
 
-def test_relation_not_exist_raise(juju_status_relation):
[e-mail]("input_file_type", ["juju-status", "juju-bundle"])
+def test_relation_not_exist_raise(input_file_type, input_files):
     """Test that raise exception when not_exist has wrong format."""
-    juju_status_relation["foo-charm"] = {
-        "charm": "cs:foo-charm-7",
-        "charm-name": "foo-charm",
-        "relations": {
-            "bar-endpoint": ["keystone"],
-        },
-        "endpoint-bindings": {
-            "": "oam-space",
-            "bar-endpoint": "oam-space",
-        },
-    }
+    input_file = input_files[input_file_type]
+
+    if input_file_type == "juju-status":
+        input_file.applications_data["foo-charm"] = {
+            "charm": "cs:foo-charm-7",
+            "charm-name": "foo-charm",
+            "relations": {
+                "bar-endpoint": ["keystone"],
+            },
+            "endpoint-bindings": {
+                "": "oam-space",
+                "bar-endpoint": "oam-space",
+            },
+        }
+
+    elif input_file_type == "juju-bundle":
+        input_file.applications_data["foo-charm"] = {
+            "charm": "cs:foo-charm-7",
+            "charm-name": "foo-charm",
+            "bindings": {
+                "": "oam-space",
+                "bar-endpoint": "oam-space",
+            },
+        }
 
     with pytest.raises(relations.RelationError):
         relation_rule = relations.RelationRule(
-            charm_to_app=CHARM_TO_APP,
-            applications=juju_status_relation,
+            input_file=input_file,
             charm=CHARM,
             relations=RELATIONS,
             not_exist=[["keystone", "foo-charm:foo-endpoint"]],
             exception=set(),
+            ubiquitous=True,
         )
         relation_rule.check()
 
 
 @pytest.mark.parametrize(
-    "expected_missing, exception",
+    "expected_missing, exception, input_file_type",
     [
-        ({"nrpe:nrpe-external-master": ["foo-charm"]}, set()),
-        ({"nrpe:nrpe-external-master": list()}, {"foo-charm"}),
+        ({"nrpe:nrpe-external-master": ["foo-charm"]}, set(), "juju-status"),
+        ({"nrpe:nrpe-external-master": list()}, {"foo-charm"}, "juju-bundle"),
     ],
 )
 def test_missing_relation_and_exception(
-    expected_missing, exception, juju_status_relation
+    expected_missing, exception, input_files, input_file_type
 ):
-    """Assert that exception is able to remove apps missing the relation."""
+    """Assert that exception rule field is able to remove apps missing the relation."""
     # add a charm in apps that has the endpoint nrpe-external-master,
     # but it's not relating with nrpe.
-    juju_status_relation["foo-charm"] = {
-        "charm": "cs:foo-charm-7",
-        "charm-name": "foo-charm",
-        "relations": {
-            "foo-endpoint": ["bar-charm"],
-        },
-        "endpoint-bindings": {
-            "": "oam-space",
-            "nrpe-external-master": "oam-space",
-        },
-    }
+    input_file = input_files[input_file_type]
+    if input_file_type == "juju-status":
+        input_file.applications_data["foo-charm"] = {
+            "charm": "cs:foo-charm-7",
+            "charm-name": "foo-charm",
+            "relations": {
+                "foo-endpoint": ["bar-charm"],
+            },
+            "endpoint-bindings": {
+                "": "oam-space",
+                "nrpe-external-master": "oam-space",
+            },
+        }
+    elif input_file_type == "juju-bundle":
+        input_file.applications_data["foo-charm"] = {
+            "charm": "cs:foo-charm-7",
+            "charm-name": "foo-charm",
+            "bindings": {
+                "": "oam-space",
+                "nrpe-external-master": "oam-space",
+            },
+        }
+        input_file.relations_data.append(
+            ["foo-charm:nrpe-external-master", "nrpe-host:nrpe-external-master"]
+        )
+
     relation_rule = relations.RelationRule(
-        charm_to_app=CHARM_TO_APP,
-        applications=juju_status_relation,
+        input_file=input_file,
         charm=CHARM,
         relations=RELATIONS,
         not_exist=[[]],
         exception=exception,
+        ubiquitous=True,
     )
     relation_rule.check()
     assert relation_rule.missing_relations == expected_missing
 
 
-def test_relation_rule_unknown_charm(mocker, juju_status_relation):
[e-mail]("input_file_type", ["juju-status", "juju-bundle"])
+def test_relation_rule_unknown_charm(mocker, input_files, input_file_type):
     """Empty relation for a unknown charm in rules and gives warning message."""
+    input_file = input_files[input_file_type]
     charm = "foo_charm"
     warning_msg = (
         "Relations rules has an unexpected format. "
@@ -139,51 +203,175 @@ def test_relation_rule_unknown_charm(mocker, juju_status_relation):
     )
     logger_mock = mocker.patch.object(relations, "LOGGER")
     relation_rule = relations.RelationRule(
-        charm_to_app=CHARM_TO_APP,
-        applications=juju_status_relation,
+        input_file=input_file,
         charm="foo_charm",
         relations=[["*:public", "keystone:public"]],
         not_exist=[[]],
         exception=set(),
+        ubiquitous=False,
     )
     assert relation_rule.relations == []
     logger_mock.warning.assert_has_calls([mocker.call(warning_msg)])
 
 
 @pytest.mark.parametrize(
-    "fake_relations, app_error, endpoint_error",
+    "fake_relations, app_error, endpoint_error, input_file_type",
     [
-        ([["foo:juju-info", "bar:juju-info"]], True, False),  # app doesn't exist
-        ([["keystone:bar", "nrpe-host:foo"]], False, True),  # endpoint doesn't exist
+        (
+            [["foo:juju-info", "bar:juju-info"]],
+            True,
+            False,
+            "juju-status",
+        ),  # app doesn't exist
+        (
+            [["foo:juju-info", "bar:juju-info"]],
+            True,
+            False,
+            "juju-bundle",
+        ),  # app doesn't exist
+        (
+            [["keystone:bar", "nrpe-host:foo"]],
+            False,
+            True,
+            "juju-status",
+        ),  # endpoint doesn't exist
+        (
+            [["keystone:bar", "nrpe-host:foo"]],
+            False,
+            True,
+            "juju-bundle",
+        ),  # endpoint doesn't exist
     ],
 )
 def test_relation_rule_unknown_app_endpoint(
-    fake_relations, app_error, endpoint_error, mocker, juju_status_relation
+    fake_relations, app_error, endpoint_error, input_files, input_file_type
 ):
     """Ensure warning message and empty relations if app or endpoint is unknown."""
-    logger_mock = mocker.patch.object(relations, "LOGGER")
-    app, endpoint = fake_relations[0][0].split(":")
-    if app_error:
-        expected_msg = f"{app} not found on applications to check relations"
-    elif endpoint_error:
-        expected_msg = f"{app} don't have the endpoint: {endpoint} to check relations"
+    input_file = input_files[input_file_type]
 
     relations_rule = relations.RelationRule(
-        charm_to_app=CHARM_TO_APP,
-        applications=juju_status_relation,
+        input_file=input_file,
         charm=CHARM,
         relations=fake_relations,
         not_exist=[[]],
         exception=set(),
+        ubiquitous=False,
     )
     # assert that relations is empty
     assert relations_rule.relations == []
-    logger_mock.warning.assert_has_calls([mocker.call(expected_msg)])
 
 
-def test_relations_rules_bootstrap(juju_status_relation):
[e-mail](
+    "machines, missing_machines, relations_to_check, input_file_type",
+    # adding new machines that nrpe is not relating
+    [
+        (
+            {"3": {"series": "focal"}, "2": {"series": "bionic"}},
+            ["2", "3"],
+            RELATIONS,
+            "juju-status",
+        ),
+        (
+            {"3": {"series": "focal"}, "2": {"series": "bionic"}},
+            ["2", "3"],
+            RELATIONS,
+            "juju-bundle",
+        ),
+        # empty relations is able to run ubiquitous check
+        (
+            {"3": {"series": "focal"}, "2": {"series": "bionic"}},
+            ["2", "3"],
+            [[]],
+            "juju-status",
+        ),
+        (
+            {"3": {"series": "focal"}, "2": {"series": "bionic"}},
+            ["2", "3"],
+            [[]],
+            "juju-bundle",
+        ),
+        (
+            {
+                "3": {
+                    "series": "focal",
+                    "containers": {
+                        "3/lxd/0": {"series": "focal"},
+                        "3/lxd/10": {"series": "focal"},
+                        "3/lxd/1": {"series": "focal"},
+                        "3/lxd/5": {"series": "focal"},
+                    },
+                }
+            },
+            # result of missing machines is sorted
+            ["3", "3/lxd/0", "3/lxd/1", "3/lxd/5", "3/lxd/10"],
+            RELATIONS,
+            "juju-status",
+        ),
+        # bundles pass the machine to deploy the containers
+        (
+            {
+                "3": {
+                    "series": "focal",
+                    "containers": ["lxd:0", "lxd:3"],
+                }
+            },
+            # result of missing machines is sorted
+            ["lxd:0", "3", "lxd:3"],
+            RELATIONS,
+            "juju-bundle",
+        ),
+    ],
+)
+def test_ubiquitous_missing_machine(
+    input_files, machines, missing_machines, relations_to_check, input_file_type
+):
+    """Test that find missing machines for an ubiquitous charm."""
+    input_file = input_files[input_file_type]
+    if input_file_type == "juju-bundle":
+        for machine in machines:
+            containers = machines[machine].pop("containers", None)
+            if containers:
+                # pass new machines and containers to deploy keystone
+                input_file.applications_data["keystone"]["to"].extend(containers)
+    input_file.machines_data.update(machines)
+    # map machines again
+    input_file.map_file()
+    relation_rule = relations.RelationRule(
+        input_file=input_file,
+        charm=CHARM,
+        relations=relations_to_check,
+        not_exist=[[]],
+        exception=set(),
+        ubiquitous=True,
+    )
+    relation_rule.check()
+    assert relation_rule.missing_machines == missing_machines
+
+
+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",
+        side_effect=NotImplementedError(),
+    )
+    input_file = input_files["juju-status"]
+    relation_rule = relations.RelationRule(
+        input_file=input_file,
+        charm=CHARM,
+        relations=RELATIONS,
+        not_exist=[[]],
+        exception=set(),
+        ubiquitous=False,
+    )
+    relation_rule.check()
+    logger_mock.debug.assert_called_once()
+
+
[e-mail]("input_file_type", ["juju-status", "juju-bundle"])
+def test_relations_rules_bootstrap(input_files, input_file_type):
     """Test RelationsRulesBootStrap object."""
-    charm_to_app = {"nrpe": {"nrpe-host", "nrpe-container"}}
+    input_file = input_files[input_file_type]
     relations_rules = [
         {
             "charm": "nrpe",
@@ -197,9 +385,8 @@ def test_relations_rules_bootstrap(juju_status_relation):
         },
     ]
     relations_rules = relations.RelationsRulesBootStrap(
-        charm_to_app=charm_to_app,
         relations_rules=relations_rules,
-        applications=juju_status_relation,
+        input_file=input_file,
     ).check()
     assert len(relations_rules) == 2
     assert all(