Sync with vm

Author: carlcsaposs-canonical

src/abstract_charm.py

@@ -61,6 +61,12 @@ class MySQLRouterCharm(ops.CharmBase, abc.ABC):
     _READ_ONLY_X_PORT = 6449
 
     refresh: charm_refresh.Common
+    # Whether `reconcile` method is allowed to run
+    # `False` if `charm_refresh.UnitTearingDown` or `charm_refresh.PeerRelationNotReady` raised
+    # Most of the charm code should not run if either of those exceptions is raised
+    # However, some charm libs (i.e. data-platform-libs) will break if they do not receive every
+    # event they expect (e.g. relation-created)
+    _reconcile_allowed: bool
 
     def __init__(self, *args) -> None:
         super().__init__(*args)
@@ -173,9 +179,14 @@ def _cos_exporter_config(self, event) -> typing.Optional[relations.cos.ExporterC
         if cos_relation_exists:
             return self._cos_relation.exporter_user_config
 
-    def get_workload(self, *, event):
-        """MySQL Router workload"""
-        if self.refresh.workload_allowed_to_start and (
+    def get_workload(self, *, event, refresh: charm_refresh.Common = None):
+        """MySQL Router workload
+
+        Pass `refresh` if `self.refresh` is not set
+        """
+        if refresh is None:
+            refresh = self.refresh
+        if refresh.workload_allowed_to_start and (
             connection_info := self._database_requires.get_connection_info(event=event)
         ):
             return self._running_workload_type(
@@ -280,18 +291,29 @@ def _update_endpoints(self) -> None:
 
     def reconcile(self, event=None) -> None:  # noqa: C901
         """Handle most events."""
+        if not self._reconcile_allowed:
+            logger.debug("Reconcile not allowed")
+            return
         workload_ = self.get_workload(event=event)
         logger.debug(
             "State of reconcile "
             f"{self._unit_lifecycle.authorized_leader=}, "
             f"{isinstance(workload_, workload.RunningWorkload)=}, "
             f"{workload_.container_ready=}, "
-            f"{self.refresh.workload_allowed_to_start= }, "
+            f"{self.refresh.workload_allowed_to_start=}, "
             f"{self._database_requires.is_relation_breaking(event)=}, "
             f"{self._database_requires.does_relation_exist()=}, "
             f"{self.refresh.in_progress=}, "
             f"{self._cos_relation.is_relation_breaking(event)=}"
         )
+        if isinstance(self.refresh, charm_refresh.Machines):
+            workload_.install(
+                unit=self.unit,
+                model_uuid=self.model.uuid,
+                snap_revision=self.refresh.pinned_snap_revision,
+                refresh=self.refresh,
+            )
+        self.unit.set_workload_version(workload_.version)
 
         # only in machine charms
         if self._ha_cluster:

src/charm.py

@@ -90,9 +90,6 @@ def __init__(self, *args) -> None:
         self._peer_data = relations.secrets.RelationSecrets(self, self._PEER_RELATION_NAME)
 
         self.framework.observe(self.on.install, self._on_install)
-        self.framework.observe(
-            self.on[rock.CONTAINER_NAME].pebble_ready, self._on_workload_container_pebble_ready
-        )
         try:
             self.refresh = charm_refresh.Kubernetes(
                 KubernetesRouterRefresh(
@@ -105,14 +102,16 @@ def __init__(self, *args) -> None:
             # MySQL server charm will clean up users & router metadata when the MySQL Router app or
             # unit(s) tear down
             self.unit.status = ops.MaintenanceStatus("Tearing down")
-            exit()
+            self._reconcile_allowed = False
         except charm_refresh.KubernetesJujuAppNotTrusted:
-            exit()
+            self._reconcile_allowed = False
         except charm_refresh.PeerRelationNotReady:
             self.unit.status = ops.MaintenanceStatus("Waiting for peer relation")
             if self.unit.is_leader():
                 self.app.status = ops.MaintenanceStatus("Waiting for peer relation")
-            exit()
+            self._reconcile_allowed = False
+        else:
+            self._reconcile_allowed = True
 
     @property
     def _subordinate_relation_endpoint_names(self) -> typing.Optional[typing.Iterable[str]]:
@@ -441,9 +440,6 @@ def _on_install(self, _) -> None:
             for port in (self._READ_WRITE_PORT, self._READ_ONLY_PORT, 6448, 6449):
                 self.unit.open_port("tcp", port)
 
-    def _on_workload_container_pebble_ready(self, _) -> None:
-        self.unit.set_workload_version(self.get_workload(event=None).version)
-
 
 if __name__ == "__main__":
     ops.main.main(KubernetesRouterCharm)

src/container.py

@@ -8,6 +8,7 @@
 import subprocess
 import typing
 
+import charm_refresh
 import ops
 
 if typing.TYPE_CHECKING:
@@ -61,6 +62,13 @@ def __init__(
         super().__init__(returncode=returncode, cmd=cmd, output=output, stderr=stderr)
 
 
+class RefreshFailed(Exception):
+    """Snap failed to refresh. Previous snap revision is still installed
+
+    Only applies to machine charm
+    """
+
+
 class Container(abc.ABC):
     """Workload container (snap or rock)"""
 
@@ -163,11 +171,33 @@ def update_mysql_router_exporter_service(
                 "`key`, `certificate` and `certificate_authority` required when tls=True"
             )
 
+    @staticmethod
+    @abc.abstractmethod
+    def install(
+        *, unit: ops.Unit, model_uuid: str, snap_revision: str, refresh: charm_refresh.Machines
+    ) -> None:
+        """Ensure snap is installed by this charm
+
+        Only applies to machine charm
+
+        If snap is not installed, install it
+        If snap is installed, check that it was installed by this charm & raise an exception otherwise
+
+        Automatically retries if snap installation fails
+        """
+
+    @staticmethod
     @abc.abstractmethod
-    def upgrade(self, unit: ops.Unit) -> None:
-        """Upgrade container version
+    def refresh(
+        *, unit: ops.Unit, model_uuid: str, snap_revision: str, refresh: charm_refresh.Machines
+    ) -> None:
+        """Refresh snap
 
         Only applies to machine charm
+
+        If snap refresh fails and previous revision is still installed, raises `RefreshFailed`
+
+        Does not automatically retry if snap installation fails
         """
 
     @abc.abstractmethod

src/rock.py

@@ -201,7 +201,12 @@ def update_mysql_router_exporter_service(
         else:
             self._container.stop(self._EXPORTER_SERVICE_NAME)
 
-    def upgrade(self, unit: ops.Unit) -> None:
+    @staticmethod
+    def install(*_, **__) -> None:
+        raise Exception("Not supported on Kubernetes")
+
+    @staticmethod
+    def refresh(*_, **__) -> None:
         raise Exception("Not supported on Kubernetes")
 
     def update_logrotate_executor_service(self, *, enabled: bool) -> None:

src/workload.py

@@ -11,6 +11,7 @@
 import string
 import typing
 
+import charm_refresh
 import ops
 import requests
 import tenacity
@@ -76,16 +77,45 @@ def version(self) -> str:
                 return component
         return ""
 
-    def upgrade(
-        self, *, event, unit: ops.Unit, tls: bool, exporter_config: "relations.cos.ExporterConfig"
+    def install(
+        self,
+        *,
+        unit: ops.Unit,
+        model_uuid: str,
+        snap_revision: str,
+        refresh: charm_refresh.Machines,
+    ) -> None:
+        """Ensure snap is installed by this charm
+
+        Only applies to machine charm
+
+        If snap is not installed, install it
+        If snap is installed, check that it was installed by this charm & raise an exception otherwise
+
+        Automatically retries if snap installation fails
+        """
+        self._container.install(
+            unit=unit, model_uuid=model_uuid, snap_revision=snap_revision, refresh=refresh
+        )
+
+    def refresh(
+        self,
+        *,
+        event,
+        unit: ops.Unit,
+        model_uuid: str,
+        snap_revision: str,
+        refresh: charm_refresh.Machines,
+        tls: bool,
+        exporter_config: "relations.cos.ExporterConfig",
     ) -> None:
-        """Upgrade MySQL Router.
+        """Refresh MySQL Router
 
         Only applies to machine charm
         """
-        logger.debug("Upgrading MySQL Router")
-        self._container.upgrade(unit=unit)
-        logger.debug("Upgraded MySQL Router")
+        self._container.refresh(
+            unit=unit, model_uuid=model_uuid, snap_revision=snap_revision, refresh=refresh
+        )
 
     @property
     def _tls_config_file_data(self) -> str:
@@ -429,8 +459,16 @@ def status(self) -> typing.Optional[ops.StatusBase]:
                 "Router was manually removed from MySQL ClusterSet. Remove & re-deploy unit"
             )
 
-    def upgrade(
-        self, *, event, unit: ops.Unit, tls: bool, exporter_config: "relations.cos.ExporterConfig"
+    def refresh(
+        self,
+        *,
+        event,
+        unit: ops.Unit,
+        model_uuid: str,
+        snap_revision: str,
+        refresh: charm_refresh.Machines,
+        tls: bool,
+        exporter_config: "relations.cos.ExporterConfig",
     ) -> None:
         enabled = self._container.mysql_router_service_enabled
         exporter_enabled = self._container.mysql_router_exporter_service_enabled
@@ -439,12 +477,27 @@ def upgrade(
         if enabled:
             logger.debug("Disabling MySQL Router service before upgrade")
             self._disable_router()
-        super().upgrade(event=event, unit=unit, tls=tls, exporter_config=exporter_config)
-        if enabled:
-            logger.debug("Re-enabling MySQL Router service after upgrade")
-            self._enable_router(event=event, tls=tls, unit_name=unit.name)
-        if exporter_enabled:
-            self._enable_exporter(tls=tls, exporter_config=exporter_config)
+        try:
+            super().refresh(
+                event=event,
+                unit=unit,
+                model_uuid=model_uuid,
+                snap_revision=snap_revision,
+                refresh=refresh,
+                tls=tls,
+                exporter_config=exporter_config,
+            )
+        except container.RefreshFailed:
+            message = "Re-enabling MySQL Router service after failed snap refresh"
+            raise
+        else:
+            message = "Re-enabling MySQL Router service after refresh"
+        finally:
+            if enabled:
+                logger.debug(message)
+                self._enable_router(event=event, tls=tls, unit_name=unit.name)
+            if exporter_enabled:
+                self._enable_exporter(tls=tls, exporter_config=exporter_config)
 
     def _wait_until_http_server_authenticates(self) -> None:
         """Wait until active connection with router HTTP server using monitoring credentials."""