Merge branch 'main' into feature/external_connectivity

Author: shayancanonical

lib/charms/operator_libs_linux/v2/snap.py

@@ -83,7 +83,7 @@
 
 # Increment this PATCH version before using `charmcraft publish-lib` or reset
 # to 0 if you are raising the major API version
-LIBPATCH = 4
+LIBPATCH = 5
 
 
 # Regex to locate 7-bit C1 ANSI sequences
@@ -580,10 +580,17 @@ def ensure(
             # We are installing or refreshing a snap.
             if self._state not in (SnapState.Present, SnapState.Latest):
                 # The snap is not installed, so we install it.
+                logger.info(
+                    "Installing snap %s, revision %s, tracking %s", self._name, revision, channel
+                )
                 self._install(channel, cohort, revision)
             else:
                 # The snap is installed, but we are changing it (e.g., switching channels).
+                logger.info(
+                    "Refreshing snap %s, revision %s, tracking %s", self._name, revision, channel
+                )
                 self._refresh(channel=channel, cohort=cohort, revision=revision, devmode=devmode)
+            logger.info("The snap installation completed successfully")
 
         self._update_snap_apps()
         self._state = state

src/abstract_charm.py

@@ -247,6 +247,10 @@ def reconcile(self, event=None) -> None:  # noqa: C901
             logger.debug("Peer relation not ready")
             return
         workload_ = self.get_workload(event=event)
+        if self._unit_lifecycle.authorized_leader and not self._upgrade.in_progress:
+            # Run before checking `self._upgrade.is_compatible` in case incompatible upgrade was
+            # forced & completed on all units.
+            self._upgrade.set_versions_in_app_databag()
         if self._upgrade.unit_state == "restarting":  # Kubernetes only
             if not self._upgrade.is_compatible:
                 logger.info(
@@ -324,8 +328,6 @@ def reconcile(self, event=None) -> None:  # noqa: C901
                 self._upgrade.unit_state = "healthy"
             if self._unit_lifecycle.authorized_leader:
                 self._upgrade.reconcile_partition()
-                if not self._upgrade.in_progress:
-                    self._upgrade.set_versions_in_app_databag()
             self.set_status(event=event)
         except server_exceptions.Error as e:
             # If not for `unit=False`, another `server_exceptions.Error` could be thrown here

src/machine_charm.py

@@ -149,6 +149,11 @@ def _on_upgrade_charm(self, _) -> None:
             # Only call `reconcile` on leader unit to avoid race conditions with `upgrade_resumed`
             self.reconcile()
 
+    def _on_resume_upgrade_action(self, event: ops.ActionEvent) -> None:
+        super()._on_resume_upgrade_action(event)
+        # If next to upgrade, upgrade leader unit
+        self.reconcile()
+
     def _on_force_upgrade_action(self, event: ops.ActionEvent) -> None:
         if not self._upgrade or not self._upgrade.in_progress:
             message = "No upgrade in progress"

src/machine_upgrade.py

@@ -29,8 +29,8 @@ class Upgrade(upgrade.Upgrade):
     @property
     def unit_state(self) -> typing.Optional[str]:
         if (
-            self._unit_workload_version is not None
-            and self._unit_workload_version != self._app_workload_version
+            self._unit_workload_container_version is not None
+            and self._unit_workload_container_version != self._app_workload_container_version
         ):
             logger.debug("Unit upgrade state: outdated")
             return "outdated"
@@ -40,28 +40,31 @@ def unit_state(self) -> typing.Optional[str]:
     def unit_state(self, value: str) -> None:
         if value == "healthy":
             # Set snap revision on first install
-            self._unit_databag["snap_revision"] = snap.REVISION
-            logger.debug(f"Saved {snap.REVISION=} in unit databag while setting state healthy")
+            self._unit_workload_container_version = snap.REVISION
+            self._unit_workload_version = self._current_versions["workload"]
+            logger.debug(
+                f'Saved {snap.REVISION=} and {self._current_versions["workload"]=} in unit databag while setting state healthy'
+            )
         # Super call
         upgrade.Upgrade.unit_state.fset(self, value)
 
     def _get_unit_healthy_status(
         self, *, workload_status: typing.Optional[ops.StatusBase]
     ) -> ops.StatusBase:
-        if self._unit_workload_version == self._app_workload_version:
+        if self._unit_workload_container_version == self._app_workload_container_version:
             if isinstance(workload_status, ops.WaitingStatus):
                 return ops.WaitingStatus(
-                    f'Router {self._current_versions["workload"]} rev {self._unit_workload_version}'
+                    f'Router {self._unit_workload_version}; Snap rev {self._unit_workload_container_version}; Charmed operator {self._current_versions["charm"]}'
                 )
             return ops.ActiveStatus(
-                f'Router {self._current_versions["workload"]} rev {self._unit_workload_version} running'
+                f'Router {self._unit_workload_version} running; Snap rev {self._unit_workload_container_version}; Charmed operator {self._current_versions["charm"]}'
             )
         if isinstance(workload_status, ops.WaitingStatus):
             return ops.WaitingStatus(
-                f'Charmed operator upgraded. Router {self._current_versions["workload"]} rev {self._unit_workload_version}'
+                f'Router {self._unit_workload_version}; Snap rev {self._unit_workload_container_version} (outdated); Charmed operator {self._current_versions["charm"]}'
             )
-        return ops.WaitingStatus(
-            f'Charmed operator upgraded. Router {self._current_versions["workload"]} rev {self._unit_workload_version} running'
+        return ops.ActiveStatus(
+            f'Router {self._unit_workload_version} running; Snap rev {self._unit_workload_container_version} (outdated); Charmed operator {self._current_versions["charm"]}'
         )
 
     @property
@@ -76,7 +79,7 @@ def app_status(self) -> typing.Optional[ops.StatusBase]:
         return super().app_status
 
     @property
-    def _unit_workload_versions(self) -> typing.Dict[str, str]:
+    def _unit_workload_container_versions(self) -> typing.Dict[str, str]:
         """{Unit name: installed snap revision}"""
         versions = {}
         for unit in self._sorted_units:
@@ -85,15 +88,28 @@ def _unit_workload_versions(self) -> typing.Dict[str, str]:
         return versions
 
     @property
-    def _unit_workload_version(self) -> typing.Optional[str]:
+    def _unit_workload_container_version(self) -> typing.Optional[str]:
         """Installed snap revision for this unit"""
         return self._unit_databag.get("snap_revision")
 
+    @_unit_workload_container_version.setter
+    def _unit_workload_container_version(self, value: str):
+        self._unit_databag["snap_revision"] = value
+
     @property
-    def _app_workload_version(self) -> str:
+    def _app_workload_container_version(self) -> str:
         """Snap revision for current charm code"""
         return snap.REVISION
 
+    @property
+    def _unit_workload_version(self) -> typing.Optional[str]:
+        """Installed MySQL Router version for this unit"""
+        return self._unit_databag.get("workload_version")
+
+    @_unit_workload_version.setter
+    def _unit_workload_version(self, value: str):
+        self._unit_databag["workload_version"] = value
+
     def reconcile_partition(self, *, action_event: ops.ActionEvent = None) -> None:
         """Handle Juju action to confirm first upgraded unit is healthy and resume upgrade."""
         if action_event:
@@ -121,7 +137,7 @@ def upgrade_resumed(self, value: bool):
 
     @property
     def authorized(self) -> bool:
-        assert self._unit_workload_version != self._app_workload_version
+        assert self._unit_workload_container_version != self._app_workload_container_version
         for index, unit in enumerate(self._sorted_units):
             if unit.name == self._unit.name:
                 # Higher number units have already upgraded
@@ -131,7 +147,8 @@ def authorized(self) -> bool:
                     return self.upgrade_resumed
                 return True
             if (
-                self._unit_workload_versions.get(unit.name) != self._app_workload_version
+                self._unit_workload_container_versions.get(unit.name)
+                != self._app_workload_container_version
                 or self._peer_relation.data[unit].get("state") != "healthy"
             ):
                 # Waiting for higher number units to upgrade
@@ -148,5 +165,8 @@ def upgrade_unit(
         logger.debug(f"Upgrading {self.authorized=}")
         self.unit_state = "upgrading"
         workload_.upgrade(unit=self._unit, tls=tls, exporter_config=exporter_config)
-        self._unit_databag["snap_revision"] = snap.REVISION
-        logger.debug(f"Saved {snap.REVISION=} in unit databag after upgrade")
+        self._unit_workload_container_version = snap.REVISION
+        self._unit_workload_version = self._current_versions["workload"]
+        logger.debug(
+            f'Saved {snap.REVISION=} and {self._current_versions["workload"]=} in unit databag after upgrade'
+        )

src/upgrade.py

@@ -113,10 +113,12 @@ def is_compatible(self) -> bool:
 
     @property
     def in_progress(self) -> bool:
-        logger.debug(f"{self._app_workload_version=} {self._unit_workload_versions=}")
+        logger.debug(
+            f"{self._app_workload_container_version=} {self._unit_workload_container_versions=}"
+        )
         return any(
-            version != self._app_workload_version
-            for version in self._unit_workload_versions.values()
+            version != self._app_workload_container_version
+            for version in self._unit_workload_container_versions.values()
         )
 
     @property
@@ -179,28 +181,28 @@ def upgrade_resumed(self) -> bool:
 
     @property
     @abc.abstractmethod
-    def _unit_workload_versions(self) -> typing.Dict[str, str]:
-        """{Unit name: unique identifier for unit's workload version}
+    def _unit_workload_container_versions(self) -> typing.Dict[str, str]:
+        """{Unit name: unique identifier for unit's workload container version}
 
         If and only if this version changes, the workload will restart (during upgrade or
         rollback).
 
         On Kubernetes, the workload & charm are upgraded together
         On machines, the charm is upgraded before the workload
 
-        This identifier should be comparable to `_app_workload_version` to determine if the unit &
-        app are the same workload version.
+        This identifier should be comparable to `_app_workload_container_version` to determine if
+        the unit & app are the same workload container version.
         """
 
     @property
     @abc.abstractmethod
-    def _app_workload_version(self) -> str:
-        """Unique identifier for the app's workload version
+    def _app_workload_container_version(self) -> str:
+        """Unique identifier for the app's workload container version
 
         This should match the workload version in the current Juju app charm version.
 
-        This identifier should be comparable to `_get_unit_workload_version` to determine if the
-        app & unit are the same workload version.
+        This identifier should be comparable to `_unit_workload_container_versions` to determine if
+        the app & unit are the same workload container version.
         """
 
     @abc.abstractmethod