DPE-1794 Implement COS integration

src/abstract_charm.py

@@ -11,14 +11,13 @@
 import ops
 import tenacity
 
-import constants
 import container
 import lifecycle
 import logrotate
 import machine_upgrade
+import relations.cos
 import relations.database_provides
 import relations.database_requires
-import relations.secrets
 import server_exceptions
 import upgrade
 import workload
@@ -29,8 +28,6 @@
 class MySQLRouterCharm(ops.CharmBase, abc.ABC):
     """MySQL Router charm"""
 
-    _COS_PEER_RELATION_NAME = "cos"
-
     def __init__(self, *args) -> None:
         super().__init__(*args)
         # Instantiate before registering other event observers
@@ -62,12 +59,6 @@ def __init__(self, *args) -> None:
             self._upgrade_relation_created,
         )
 
-        self.cos_secrets = relations.secrets.RelationSecrets(
-            self,
-            self._COS_PEER_RELATION_NAME,
-            unit_secret_fields=[constants.MONITORING_PASSWORD_KEY],
-        )
-
     @property
     @abc.abstractmethod
     def _subordinate_relation_endpoint_names(self) -> typing.Optional[typing.Iterable[str]]:
@@ -76,12 +67,6 @@ def _subordinate_relation_endpoint_names(self) -> typing.Optional[typing.Iterabl
         Does NOT include relations where charm is principal
         """
 
-    @property
-    def _tls_certificate_saved(self) -> bool:
-        """Whether a TLS certificate is available to use"""
-        # TODO VM TLS: Remove property after implementing TLS on machine charm
-        return False
-
     @property
     @abc.abstractmethod
     def _container(self) -> container.Container:
@@ -97,6 +82,11 @@ def _upgrade(self) -> typing.Optional[upgrade.Upgrade]:
     def _logrotate(self) -> logrotate.LogRotate:
         """logrotate"""
 
+    @property
+    @abc.abstractmethod
+    def _cos(self) -> relations.cos.COSRelation:
+        """COS"""
+
     @property
     @abc.abstractmethod
     def _read_write_endpoint(self) -> str:
@@ -107,6 +97,31 @@ def _read_write_endpoint(self) -> str:
     def _read_only_endpoint(self) -> str:
         """MySQL Router read-only endpoint"""
 
+    @property
+    def tls_certificate_saved(self) -> bool:
+        """Whether a TLS certificate is available to use"""
+        # TODO VM TLS: Remove property after implementing TLS on machine_charm
+        return False
+
+    @property
+    def tls_key(self) -> str:
+        """Custom TLS key"""
+        # TODO VM TLS: Remove property after implementing TLS on machine_charm
+        return None
+
+    @property
+    def tls_certificate(self) -> str:
+        """Custom TLS certificate"""
+        # TODO VM TLS: Remove property after implementing TLS on machine_charm
+        return None
+
+    def cos_exporter_config(self, event) -> relations.cos.ExporterConfig:
+        """Returns the exporter config for MySQLRouter exporter if cos relation exists"""
+        cos_relation_exists = self._cos.relation_exists and not self._cos.is_relation_breaking(
+            event
+        )
+        return self._cos.exporter_user_config if cos_relation_exists else None
+
     def get_workload(self, *, event):
         """MySQL Router workload"""
         if connection_info := self._database_requires.get_connection_info(event=event):
@@ -118,7 +133,7 @@ def get_workload(self, *, event):
                 charm_=self,
             )
         return self._workload_type(
-            container_=self._container, logrotate_=self._logrotate, cos=self._cos
+            container_=self._container, logrotate_=self._logrotate, cos=self._cos, charm_=self
         )
 
     @staticmethod
@@ -230,7 +245,7 @@ def reconcile(self, event=None) -> None:  # noqa: C901
                 return
             if self._upgrade.unit_state == "outdated":
                 if self._upgrade.authorized:
-                    self._upgrade.upgrade_unit(workload_=workload_, tls=False)
+                    self._upgrade.upgrade_unit(workload_=workload_, tls=self.tls_certificate_saved)
                 else:
                     self.set_status(event=event)
                     logger.debug("Waiting to upgrade")
@@ -265,13 +280,7 @@ def reconcile(self, event=None) -> None:  # noqa: C901
                         shell=workload_.shell,
                     )
             if workload_.container_ready:
-                cos_relation_exists = (
-                    self._cos.relation_exists and not self._cos.is_relation_breaking(event)
-                )
-                workload_.reconcile(
-                    unit_name=self.unit.name,
-                    exporter_config=self._cos.exporter_user_info if cos_relation_exists else None,
-                )
+                workload_.reconcile_services(event)
             # Empty waiting status means we're waiting for database requires relation before
             # starting workload
             if not workload_.status or workload_.status == ops.WaitingStatus():

src/container.py

@@ -142,6 +142,8 @@ def update_mysql_router_exporter_service(
             enabled: Whether MySQL Router exporter service is enabled
             config: The configuration for MySQL Router exporter
         """
+        if enabled and not config:
+            raise ValueError("Missing MySQL Router exporter config")
 
     @abc.abstractmethod
     def upgrade(self, unit: ops.Unit) -> None:

src/machine_charm.py

@@ -31,7 +31,7 @@ def __init__(self, *args) -> None:
         super().__init__(*args)
         # DEPRECATED shared-db: Enable legacy "mysql-shared" interface
         self._database_provides = relations.database_providers_wrapper.RelationEndpoint(self)
-        self._cos = relations.cos.COSRelation(self, self._container)
+        self._cos_relation = relations.cos.COSRelation(self, self._container)
 
         self._authenticated_workload_type = socket_workload.AuthenticatedSocketWorkload
         self.framework.observe(self.on.install, self._on_install)
@@ -61,6 +61,10 @@ def _upgrade(self) -> typing.Optional[machine_upgrade.Upgrade]:
     def _logrotate(self) -> machine_logrotate.LogRotate:
         return machine_logrotate.LogRotate(container_=self._container)
 
+    @property
+    def _cos(self) -> relations.cos.COSRelation:
+        return self._cos_relation
+
     @property
     def _read_write_endpoint(self) -> str:
         return f'file://{self._container.path("/run/mysqlrouter/mysql.sock")}'
@@ -107,7 +111,7 @@ def _on_force_upgrade_action(self, event: ops.ActionEvent) -> None:
         logger.debug("Forcing upgrade")
         event.log(f"Forcefully upgrading {self.unit.name}")
         self._upgrade.upgrade_unit(
-            workload_=self.get_workload(event=None), tls=self._tls_certificate_saved
+            workload_=self.get_workload(event=None), tls=self.tls_certificate_saved
         )
         self.reconcile()
         event.set_results({"result": f"Forcefully upgraded {self.unit.name}"})

src/relations/cos.py

@@ -9,10 +9,9 @@
 
 import ops
 from charms.grafana_agent.v0.cos_agent import COSAgentProvider
-from relations.secrets import UNIT_SCOPE
 
-import constants
 import container
+import relations.secrets
 import utils
 from snap import _SNAP_NAME
 
@@ -22,6 +21,7 @@
 logger = logging.getLogger(__name__)
 
 MONITORING_USERNAME = "monitoring"
+MONITORING_PASSWORD_KEY = "monitoring-password"
 
 
 @dataclass
@@ -39,6 +39,7 @@ class COSRelation:
     _EXPORTER_PORT = "49152"
     _HTTP_SERVER_PORT = "8443"
     _NAME = "cos-agent"
+    _PEER_RELATION_NAME = "cos"
 
     def __init__(self, charm_: "abstract_charm.MySQLRouterCharm", container_: container.Container):
         self._interface = COSAgentProvider(
@@ -63,9 +64,15 @@ def __init__(self, charm_: "abstract_charm.MySQLRouterCharm", container_: contai
             charm_.reconcile,
         )
 
+        self._secrets = relations.secrets.RelationSecrets(
+            charm_,
+            self._PEER_RELATION_NAME,
+            unit_secret_fields=[MONITORING_PASSWORD_KEY],
+        )
+
     @property
-    def exporter_user_info(self) -> dict:
-        """Returns user info needed for the router exporter service."""
+    def exporter_user_config(self) -> dict:
+        """Returns user config needed for the router exporter service."""
         return ExporterConfig(
             url=f"https://127.0.0.1:{self._HTTP_SERVER_PORT}",
             username=MONITORING_USERNAME,
@@ -79,21 +86,21 @@ def relation_exists(self) -> bool:
 
     def _get_monitoring_password(self) -> str:
         """Gets the monitoring password from unit peer data, or generate and cache it."""
-        monitoring_password = self.charm.cos_secrets.get_secret(
-            UNIT_SCOPE, constants.MONITORING_PASSWORD_KEY
+        monitoring_password = self._secrets.get_secret(
+            relations.secrets.UNIT_SCOPE, MONITORING_PASSWORD_KEY
         )
         if monitoring_password:
             return monitoring_password
 
         monitoring_password = utils.generate_password()
-        self.charm.cos_secrets.set_secret(
-            UNIT_SCOPE, constants.MONITORING_PASSWORD_KEY, monitoring_password
+        self._secrets.set_secret(
+            relations.secrets.UNIT_SCOPE, MONITORING_PASSWORD_KEY, monitoring_password
         )
         return monitoring_password
 
     def _reset_monitoring_password(self) -> None:
         """Reset the monitoring password from unit peer data."""
-        self.charm.cos_secrets.set_secret(UNIT_SCOPE, constants.MONITORING_PASSWORD_KEY, None)
+        self._secrets.set_secret(relations.secrets.UNIT_SCOPE, MONITORING_PASSWORD_KEY, None)
 
     def is_relation_breaking(self, event) -> bool:
         """Whether relation will be broken after the current event is handled."""

src/snap.py

@@ -179,17 +179,14 @@ def update_mysql_router_service(self, *, enabled: bool, tls: bool = None) -> Non
             raise NotImplementedError  # TODO VM TLS
 
         if enabled:
-            _snap.set({"mysqlrouter.extra-options": f"--extra-config {self.rest_api_config_file}"})
             _snap.start([self._SERVICE_NAME], enable=True)
         else:
-            _snap.unset("mysqlrouter.extra-options")
             _snap.stop([self._SERVICE_NAME], disable=True)
 
     def update_mysql_router_exporter_service(
         self, *, enabled: bool, config: "relations.cos.ExporterConfig" = None
     ) -> None:
-        if enabled and not config:
-            raise ValueError("Missing MySQL Router exporter config")
+        super().update_mysql_router_exporter_service(enabled=enabled, config=config)
 
         if enabled:
             _snap.set(