mongo-charms-single-kernel 1.8.9__tar.gz → 1.8.11__tar.gz

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mongo-charms-single-kernel
-Version: 1.8.9
+Version: 1.8.11
 Summary: Shared and reusable code for Mongo-related charms
 License-Expression: Apache-2.0
 License-File: LICENSE

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/pyproject.toml

@@ -40,7 +40,7 @@ dependencies = [
     "python-ldap",
     "charm-refresh (>=3.1.0.2,<4.0.0.0)"
 ]
-version = "1.8.9"
+version = "1.8.11"
 
 [project.urls]
 homepage = "https://github.com/canonical/mongo-single-kernel-library"
@@ -136,6 +136,8 @@ more_itertools = "*"
 httpx = "*"
 boto3 = "^1.37.12"
 mypy-boto3-s3 = "^1.37.0"
+tomli = '*'
+tomli-w = '*'
 
 [tool.ruff]
 target-version = "py310"
@@ -206,7 +208,8 @@ exclude = [
     "^single_kernel_mongo/lib/*",
     "tests/charms/*",
     "tests/integration/*",
-    "tests/unit/*"
+    "tests/unit/*",
+    "typings[\\/].*"
 ]
 # https://mypy.readthedocs.io/en/stable/command_line.html#cmdoption-mypy-ignore-missing-imports
 ignore_missing_imports = true

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/config/literals.py

@@ -51,13 +51,13 @@ class MongoPorts(IntEnum):
 class InternalUsernames(str, Enum):
     """The allowed internal usernames."""
 
-    OPERATOR = "operator"
-    BACKUP = "backup"
-    MONITOR = "monitor"
-    LOGROTATE = "logrotate"
+    CHARMED_OPERATOR = "charmed-operator"
+    CHARMED_BACKUP = "charmed-backup"
+    CHARMED_STATS = "charmed-stats"
+    CHARMED_LOGROTATE = "charmed-logrotate"
 
 
-SECRETS_APP = [f"{user}-password" for user in InternalUsernames] + ["keyfile"]
+SECRETS_APP = [f"{username}-password" for username in InternalUsernames] + ["keyfile"]
 
 VERSIONS_FILE = Path("refresh_versions.toml")
 

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/core/abstract_upgrades_v3.py

@@ -4,6 +4,7 @@ import abc
 import dataclasses
 import logging
 
+import charm_ as charm_api
 import charm_refresh
 import poetry.core.constraints.version as poetry_version
 from tenacity import RetryError
@@ -12,9 +13,7 @@ from typing_extensions import override
 from single_kernel_mongo.config.literals import CharmKind
 from single_kernel_mongo.config.models import BackupState
 from single_kernel_mongo.core.operator import OperatorProtocol
-from single_kernel_mongo.exceptions import (
-    FailedToMovePrimaryError,
-)
+from single_kernel_mongo.exceptions import FailedToMovePrimaryError
 from single_kernel_mongo.managers.upgrade_v3 import MongoDBUpgradesManager
 from single_kernel_mongo.state.charm_state import CharmState
 
@@ -108,6 +107,15 @@ class MongoDBRefresh(charm_refresh.CharmSpecificCommon, abc.ABC):
             logger.error("Cluster cannot read/write to replicas")
             raise charm_refresh.PrecheckFailed("Cluster is not able to read/write to replicas")
 
+        if not (
+            isinstance(charm_api.event, charm_api.ActionEvent)
+            and charm_api.event.action == "pre-refresh-check"
+        ):
+            logger.info(
+                "Not checking the compatibility version, this can only run in manual pre-refresh-check."
+            )
+            return
+
         fcv = self.state.app_peer_data.feature_compatibility_version
         if not self.upgrades_manager.is_feature_compatibility_version(fcv):
             logger.info(

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/core/operator.py

@@ -393,3 +393,10 @@ class OperatorProtocol(ABC, Object, ManagerStatusProtocol):
             return
 
         Path(self.state.paths.conf_path).mkdir(exist_ok=True)
+
+    def instantiate_keyfile(self):
+        """Instantiate the keyfile."""
+        if not (keyfile := self.state.get_keyfile()):
+            raise Exception("Waiting for leader unit to generate keyfile contents")
+
+        self.workload.write(self.workload.paths.keyfile, keyfile)

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/core/version_checker.py

@@ -42,14 +42,6 @@ class VersionChecker:
             "-locally built" if self.version_checker.is_local_charm(self.charm.app.name) else ""
         )
         try:
-            # This part needs some explanation: On VM, if we are running this
-            # during the pre-refresh hook that happens after the upgrade, all
-            # charm codes have been refreshed.
-            # We want to check our version against the already upgraded config server, so
-            # we use the current revision that stores the revision of the
-            # former charm until that unit is fully upgraded.
-            old_version = self.version_checker.version
-            self.version_checker.version = self.state.unit_peer_data.current_revision
             if self.version_checker.are_related_apps_valid():
                 return None
         except NoVersionError as e:
@@ -61,10 +53,6 @@ class VersionChecker:
                     current_charms_version, local_identifier
                 )
 
-        finally:
-            # Always restore the former version.
-            self.version_checker.version = old_version
-
         if self.state.is_role(MongoDBRoles.SHARD):
             config_server_revision = self.version_checker.get_version_of_related_app(
                 self.state.config_server_name

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/managers/config.py

@@ -28,7 +28,11 @@ from single_kernel_mongo.core.structured_config import MongoConfigModel, MongoDB
 from single_kernel_mongo.core.workload import WorkloadBase
 from single_kernel_mongo.exceptions import WorkloadServiceError
 from single_kernel_mongo.state.charm_state import CharmState
-from single_kernel_mongo.utils.mongodb_users import BackupUser, LogRotateUser, MonitorUser
+from single_kernel_mongo.utils.mongodb_users import (
+    CharmedBackupUser,
+    CharmedLogRotateUser,
+    CharmedStatsUser,
+)
 from single_kernel_mongo.workload import (
     get_logrotate_workload_for_substrate,
     get_mongodb_exporter_workload_for_substrate,
@@ -135,7 +139,7 @@ class BackupConfigManager(CommonConfigManager):
             logger.info("Not starting PBM yet. Shard not added to config-server")
             return
 
-        if not self.state.get_user_password(BackupUser):
+        if not self.state.get_user_password(CharmedBackupUser):
             logger.info("No password found.")
             return
 
@@ -184,7 +188,7 @@ class LogRotateConfigManager(CommonConfigManager):
             logger.info("DB is not initialised.")
             return
 
-        if not self.state.get_user_password(LogRotateUser):
+        if not self.state.get_user_password(CharmedLogRotateUser):
             logger.info("No password found.")
             return
 
@@ -224,17 +228,17 @@ class MongoDBExporterConfigManager(CommonConfigManager):
 
     @override
     def build_parameters(self) -> list[list[str]]:
-        return [[self.state.monitor_config.uri]]
+        return [[self.state.stats_config.uri]]
 
     def configure_and_restart(self):
         """Exposes the endpoint to mongodb_exporter."""
         if not self.state.db_initialised:
             return
 
-        if not self.state.get_user_password(MonitorUser):
+        if not self.state.get_user_password(CharmedStatsUser):
             return
 
-        if not self.workload.active() or self.get_environment() != self.state.monitor_config.uri:
+        if not self.workload.active() or self.get_environment() != self.state.stats_config.uri:
             try:
                 # Always enable the service
                 self.workload.stop()

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/managers/mongo.py

@@ -52,11 +52,11 @@ from single_kernel_mongo.utils.mongo_config import (
 from single_kernel_mongo.utils.mongo_connection import MongoConnection, NotReadyError
 from single_kernel_mongo.utils.mongodb_users import (
     OPERATOR_ROLE,
-    BackupUser,
-    LogRotateUser,
+    CharmedBackupUser,
+    CharmedLogRotateUser,
+    CharmedOperatorUser,
+    CharmedStatsUser,
     MongoDBUser,
-    MonitorUser,
-    OperatorUser,
 )
 
 if TYPE_CHECKING:
@@ -138,12 +138,12 @@ class MongoManager(Object, ManagerStatusProtocol):
 
     def initialise_charm_admin_users(self) -> None:
         """First initialisation of each user."""
-        self.initialise_operator_user()
-        self.initialise_user(MonitorUser)
-        self.initialise_user(BackupUser)
-        self.initialise_user(LogRotateUser)
+        self.initialise_charmed_operator_user()
+        self.initialise_user(CharmedStatsUser)
+        self.initialise_user(CharmedBackupUser)
+        self.initialise_user(CharmedLogRotateUser)
 
-    def initialise_operator_user(self):
+    def initialise_charmed_operator_user(self):
         """Creates initial admin user for MongoDB.
 
         Initial admin user can be created only through localhost connection.
@@ -154,7 +154,7 @@ class MongoManager(Object, ManagerStatusProtocol):
         It is needed to install mongodb-clients inside charm container to make
         this function work correctly.
         """
-        if self.state.app_peer_data.is_user_created(OperatorUser.username):
+        if self.state.app_peer_data.is_user_created(CharmedOperatorUser.username):
             return
         config = self.state.mongo_config
         cmd = [
@@ -169,7 +169,7 @@ class MongoManager(Object, ManagerStatusProtocol):
             '})"',
         ]
         self.workload.run_bin_command("mongodb://localhost/admin", cmd, input=config.password)
-        self.state.app_peer_data.set_user_created(OperatorUser.username)
+        self.state.app_peer_data.set_user_created(CharmedOperatorUser.username)
 
     def initialise_user(self, user: MongoDBUser):
         """Creates a user and sets its role on the MongoDB database."""

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/managers/mongodb_operator.py

@@ -33,10 +33,7 @@ from single_kernel_mongo.config.models import (
     PasswordManagementContext,
     PasswordManagementState,
 )
-from single_kernel_mongo.config.relations import (
-    ExternalRequirerRelations,
-    RelationNames,
-)
+from single_kernel_mongo.config.relations import ExternalRequirerRelations, RelationNames
 from single_kernel_mongo.config.statuses import (
     BackupStatuses,
     CharmStatuses,
@@ -100,12 +97,12 @@ from single_kernel_mongo.state.charm_state import CharmState
 from single_kernel_mongo.utils.helpers import is_valid_ldap_options, is_valid_ldapusertodnmapping
 from single_kernel_mongo.utils.mongo_connection import MongoConnection, NotReadyError
 from single_kernel_mongo.utils.mongodb_users import (
-    BackupUser,
+    CharmedBackupUser,
+    CharmedLogRotateUser,
+    CharmedOperatorUser,
+    CharmedStatsUser,
     InternalUsers,
-    LogRotateUser,
     MongoDBUser,
-    MonitorUser,
-    OperatorUser,
     get_user_from_username,
     validate_charm_user_password_config,
 )
@@ -236,7 +233,7 @@ class MongoDBOperator(OperatorProtocol, Object):
             raise
 
         self.upgrades_status_manager = MongoDBUpgradesStatusManager(
-            state=self.state, workload=self.workload, refresh=self.refresh
+            self, state=self.state, workload=self.workload, refresh=self.refresh
         )
 
         self.sysctl_config = sysctl.Config(name=self.charm.app.name)
@@ -274,13 +271,13 @@ class MongoDBOperator(OperatorProtocol, Object):
         if not self.refresh:
             return
 
+        # Update the version across all relations so that we can notify other units
+        self.cross_app_version_checker.set_version_across_all_relations()
+
         if self.state.app_peer_data.feature_compatibility_version == FEATURE_VERSION:
             # We have already run all this logic before, no need to run it again.
             return
 
-        # Update the version across all relations so that we can notify other units
-        self.cross_app_version_checker.set_version_across_all_relations()
-
         if (
             self.state.is_role(MongoDBRoles.CONFIG_SERVER)
             and not self.cross_app_version_checker.are_related_apps_valid()
@@ -324,12 +321,15 @@ class MongoDBOperator(OperatorProtocol, Object):
 
         if not refresh.workload_allowed_to_start:
             return
+
         logger.info("Restarting workloads")
         # always apply the current charm revision's config
         self._configure_workloads()
         self.start_charm_services()
 
-        self.state.unit_peer_data.current_revision = self.cross_app_version_checker.version
+        if self.charm.unit.is_leader():
+            # Update the version across all relations so that we can notify other units
+            self.cross_app_version_checker.set_version_across_all_relations()
 
         if self.name == CharmKind.MONGOD:
             self._restart_related_services()
@@ -391,13 +391,13 @@ class MongoDBOperator(OperatorProtocol, Object):
         """The ordered list of components for this operator."""
         return (
             self,
+            self.upgrades_status_manager,
             self.mongo_manager,
             self.tls_manager,
             self.shard_manager,
             self.config_server_manager,
             self.backup_manager,
             self.ldap_manager,
-            self.upgrades_status_manager,
         )
 
     # BEGIN: Handlers.
@@ -480,7 +480,7 @@ class MongoDBOperator(OperatorProtocol, Object):
         if not self.mongo_manager.mongod_ready():
             raise WorkloadNotReadyError
 
-        self.state.statuses.set(CharmStatuses.ACTIVE_IDLE.value, scope="unit", component=self.name)
+        self.state.statuses.clear(scope="unit", component=self.name)
 
         try:
             self._initialise_replica_set()
@@ -503,7 +503,7 @@ class MongoDBOperator(OperatorProtocol, Object):
             logger.error("Could not restart the related services.")
             return
 
-        self.state.statuses.set(CharmStatuses.ACTIVE_IDLE.value, scope="unit", component=self.name)
+        self.state.statuses.clear(scope="unit", component=self.name)
 
     @override
     def prepare_for_shutdown(self) -> None:  # pragma: nocover
@@ -719,10 +719,10 @@ class MongoDBOperator(OperatorProtocol, Object):
 
         Adds the unit as a replica to the MongoDB replica set.
         """
-        # Changing the monitor or the backup password will lead to non-leader
-        # units receiving a relation changed event. We must update the monitor
-        # and pbm URI if the password changes so that COS/pbm can continue to
-        # work.
+        # Changing the charmed-stats or the charmed-backup password will lead
+        # to non-leader units receiving a relation changed event. We must update
+        # the monitor and pbm URI if the password changes so that COS/pbm can
+        # continue to work.
         if self.state.db_initialised and self.workload.active():
             self.mongodb_exporter_config_manager.configure_and_restart()
             self.backup_manager.configure_and_restart()
@@ -912,16 +912,18 @@ class MongoDBOperator(OperatorProtocol, Object):
     def update_single_user_password(self, user: MongoDBUser, new_password: str) -> None:
         """Set password in Mongod and restart the appropriate services."""
         self.mongo_manager.set_user_password(user, new_password)
-        if user == BackupUser:
+        if user == CharmedBackupUser:
             # Update and restart PBM Agent.
             self.backup_manager.configure_and_restart()
-        if user == MonitorUser:
+        if user == CharmedStatsUser:
             # Update and restart mongodb exporter.
             self.mongodb_exporter_config_manager.configure_and_restart()
-        if user == LogRotateUser:
+        if user == CharmedLogRotateUser:
             # Update and restart logrotate.
             self.logrotate_config_manager.configure_and_restart()
-        if user in (OperatorUser, BackupUser) and self.state.is_role(MongoDBRoles.CONFIG_SERVER):
+        if user in (CharmedOperatorUser, CharmedBackupUser) and self.state.is_role(
+            MongoDBRoles.CONFIG_SERVER
+        ):
             self.config_server_manager.update_credentials(
                 user.password_key_name,
                 new_password,
@@ -1151,13 +1153,6 @@ class MongoDBOperator(OperatorProtocol, Object):
         # Sets directory permissions
         self.set_permissions()
 
-    def instantiate_keyfile(self):
-        """Instantiate the keyfile."""
-        if not (keyfile := self.state.get_keyfile()):
-            raise Exception("Waiting for leader unit to generate keyfile contents")
-
-        self.workload.write(self.workload.paths.keyfile, keyfile)
-
     def _initialise_replica_set(self):
         """Helpful method to initialise the replica set and the users.
 

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/managers/mongos_operator.py

@@ -20,12 +20,7 @@ from ops.model import Relation, Unit
 from pymongo.errors import PyMongoError
 from typing_extensions import override
 
-from single_kernel_mongo.config.literals import (
-    CharmKind,
-    MongoPorts,
-    Scope,
-    Substrates,
-)
+from single_kernel_mongo.config.literals import CharmKind, MongoPorts, Scope, Substrates
 from single_kernel_mongo.config.models import ROLES
 from single_kernel_mongo.config.relations import ExternalRequirerRelations, RelationNames
 from single_kernel_mongo.config.statuses import CharmStatuses, MongosStatuses
@@ -57,9 +52,7 @@ from single_kernel_mongo.managers.upgrade_v3 import MongoDBUpgradesManager
 from single_kernel_mongo.managers.upgrade_v3_status import MongoDBUpgradesStatusManager
 from single_kernel_mongo.state.app_peer_state import AppPeerDataKeys
 from single_kernel_mongo.state.charm_state import CharmState
-from single_kernel_mongo.workload import (
-    get_mongos_workload_for_substrate,
-)
+from single_kernel_mongo.workload import get_mongos_workload_for_substrate
 from single_kernel_mongo.workload.mongos_workload import MongosWorkload
 
 if TYPE_CHECKING:
@@ -137,7 +130,7 @@ class MongosOperator(OperatorProtocol, Object):
             sys.exit()
 
         self.upgrades_status_manager = MongoDBUpgradesStatusManager(
-            self.state, self.workload, self.refresh
+            self, self.state, self.workload, self.refresh
         )
 
         # LDAP Manager, which covers both send-ca-cert interface and ldap interface.
@@ -169,6 +162,9 @@ class MongosOperator(OperatorProtocol, Object):
 
         Checks if unit is healthy and allow the next unit to update.
         """
+        if not self.state.db_initialised:
+            return
+
         if not refresh.workload_allowed_to_start:
             return
 
@@ -178,7 +174,7 @@ class MongosOperator(OperatorProtocol, Object):
         self._configure_workloads()
         self.start_charm_services()
 
-        logger.debug("Running post refresh checks to verify monogs is not broken after refresh")
+        logger.debug("Running post refresh checks to verify mongos is not broken after refresh")
         if not self.state.db_initialised:
             refresh.next_unit_allowed_to_refresh = True
             return
@@ -232,6 +228,12 @@ class MongosOperator(OperatorProtocol, Object):
 
         self.mongos_config_manager.set_environment()
 
+        # Instantiate the keyfile
+        try:
+            self.instantiate_keyfile()
+        except Exception:
+            logger.info("Not instantiating as we don't have a keyfile yet.")
+
     @override
     def prepare_for_startup(self) -> None:
         """For this case, we don't start any service.
@@ -248,19 +250,24 @@ class MongosOperator(OperatorProtocol, Object):
 
         if self.refresh.in_progress:
             # Bypass the regular start if refresh is in progress
+            logger.info("Refresh in progress, skipping regular start")
             return
 
         self._configure_workloads()
 
-        # start hooks are fired before relation hooks and `mongos` requires a config-server in
+        if self.state.mongos_cluster_relation:
+            self.instantiate_keyfile()
+            self.start_charm_services()
+            return
+
+        # start hooks that are fired before relation hooks and `mongos` requires a config-server in
         # order to start. Wait to receive config-server info from the relation event before
         # starting `mongos` daemon
-        if not self.state.mongos_cluster_relation:
-            self.state.statuses.add(
-                MongosStatuses.MISSING_CONF_SERVER_REL.value,
-                scope="unit",
-                component=self.name,
-            )
+        self.state.statuses.add(
+            MongosStatuses.MISSING_CONF_SERVER_REL.value,
+            scope="unit",
+            component=self.name,
+        )
 
     @override
     def update_secrets_and_restart(self, secret_label: str, secret_id: str) -> None:

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.11}/single_kernel_mongo/managers/sharding.py

@@ -18,9 +18,7 @@ from data_platform_helpers.advanced_statuses.models import StatusObject
 from data_platform_helpers.advanced_statuses.protocol import ManagerStatusProtocol
 from data_platform_helpers.advanced_statuses.types import Scope
 from ops.framework import Object
-from ops.model import (
-    Relation,
-)
+from ops.model import Relation
 from pymongo.errors import (
     NotPrimaryError,
     OperationFailure,
@@ -37,10 +35,7 @@ from single_kernel_mongo.config.literals import (
 )
 from single_kernel_mongo.config.models import BackupState
 from single_kernel_mongo.config.relations import RelationNames
-from single_kernel_mongo.config.statuses import (
-    ConfigServerStatuses,
-    ShardStatuses,
-)
+from single_kernel_mongo.config.statuses import ConfigServerStatuses, ShardStatuses
 from single_kernel_mongo.core.structured_config import MongoDBRoles
 from single_kernel_mongo.exceptions import (
     BalancerNotEnabledError,
@@ -62,9 +57,9 @@ from single_kernel_mongo.state.tls_state import SECRET_CA_LABEL
 from single_kernel_mongo.utils.mongo_connection import MongoConnection, NotReadyError
 from single_kernel_mongo.utils.mongo_error_codes import MongoErrorCodes
 from single_kernel_mongo.utils.mongodb_users import (
-    BackupUser,
+    CharmedBackupUser,
+    CharmedOperatorUser,
     MongoDBUser,
-    OperatorUser,
 )
 from single_kernel_mongo.workload.mongodb_workload import MongoDBWorkload
 
@@ -108,10 +103,10 @@ class ConfigServerManager(Object, ManagerStatusProtocol):
             )
         relation_data = {
             AppShardingComponentKeys.OPERATOR_PASSWORD.value: self.state.get_user_password(
-                OperatorUser
+                CharmedOperatorUser
             ),
             AppShardingComponentKeys.BACKUP_PASSWORD.value: self.state.get_user_password(
-                BackupUser
+                CharmedBackupUser
             ),
             AppShardingComponentKeys.KEY_FILE.value: self.state.get_keyfile(),
             AppShardingComponentKeys.HOST.value: json.dumps(sorted(self.state.internal_hosts)),
@@ -195,11 +190,8 @@ class ConfigServerManager(Object, ManagerStatusProtocol):
         # Note: we permit this logic based on status since we aren't checking
         # self.charm.unit.status`, instead `get_cluster_mismatched_revision_status` directly
         # computes the revision check.
-        if (
-            rev_status
-            := self.dependent.cluster_version_checker.get_cluster_mismatched_revision_status()
-        ):
-            self.state.statuses.add(rev_status, scope="app", component=self.dependent.name)
+        if self.dependent.cluster_version_checker.get_cluster_mismatched_revision_status():
+            # The status will be added during the get status
             raise DeferrableFailedHookChecksError("Mismatched versions in the cluster")
 
     def assert_pass_hook_checks(self, relation: Relation, leaving: bool = False) -> None:
@@ -476,8 +468,8 @@ class ConfigServerManager(Object, ManagerStatusProtocol):
             if not hosts:
                 return unreachable_hosts
 
-            # use a URI that is not dependent on the operator password, as we are not guaranteed
-            # that the shard has received the password yet.
+            # use a URI that is not dependent on the charmed-operator password, as we are
+            # not guaranteed that the shard has received the password yet.
             # To check if the shard is ready, we check the entire replica set for readiness
             uri = f"mongodb://{','.join(hosts)}"
             if not self.dependent.mongo_manager.mongod_ready(uri, direct=False):
@@ -526,11 +518,8 @@ class ShardManager(Object, ManagerStatusProtocol):
         # Note: we permit this logic based on status since we aren't checking
         # self.charm.unit.status`, instead `get_cluster_mismatched_revision_status` directly
         # computes the revision check.
-        if (
-            rev_status
-            := self.dependent.cluster_version_checker.get_cluster_mismatched_revision_status()
-        ):
-            self.state.statuses.add(rev_status, scope="app", component=self.dependent.name)
+        if self.dependent.cluster_version_checker.get_cluster_mismatched_revision_status():
+            # The status will be added during the get status
             raise DeferrableFailedHookChecksError("Mismatched versions in the cluster")
 
     def assert_pass_hook_checks(self, relation: Relation, is_leaving: bool = False) -> None:
@@ -637,7 +626,7 @@ class ShardManager(Object, ManagerStatusProtocol):
         self.state.app_peer_data.mongos_hosts = self.state.shard_state.mongos_hosts
 
     def handle_secret_changed(self, secret_label: str | None) -> None:
-        """Update operator and backup user passwords when rotation occurs.
+        """Update charmed-operator and charmed-backup user passwords when rotation occurs.
 
         Changes in secrets do not re-trigger a relation changed event, so it is necessary to listen
         to secret changes events.
@@ -665,7 +654,9 @@ class ShardManager(Object, ManagerStatusProtocol):
             backup_password = self.state.shard_state.backup_password
 
             if not operator_password or not backup_password:
-                raise WaitingForSecretsError("Missing operator password or backup password")
+                raise WaitingForSecretsError(
+                    "Missing charmed-operator password or charmed-backup password"
+                )
             self.sync_cluster_passwords(operator_password, backup_password)
 
         # Add the certificate if it is present
@@ -764,7 +755,10 @@ class ShardManager(Object, ManagerStatusProtocol):
                     )
                     raise NotReadyError
 
-        for user, password in ((OperatorUser, operator_password), (BackupUser, backup_password)):
+        for user, password in (
+            (CharmedOperatorUser, operator_password),
+            (CharmedBackupUser, backup_password),
+        ):
             try:
                 self.update_password(user=user, new_password=password)
             except SetPasswordError:
@@ -888,7 +882,7 @@ class ShardManager(Object, ManagerStatusProtocol):
             )
             return False
 
-        config = self.state.mongos_config_for_user(OperatorUser, set(mongos_hosts))
+        config = self.state.mongos_config_for_user(CharmedOperatorUser, set(mongos_hosts))
 
         drained = shard_name not in self.dependent.mongo_manager.get_draining_shards(
             config=config, shard_name=shard_name
@@ -927,9 +921,13 @@ class ShardManager(Object, ManagerStatusProtocol):
 
     def should_synchronise_cluster_passwords(self) -> bool:
         """Decides if we should synchronise cluster passwords or not."""
-        if self.state.shard_state.operator_password != self.state.get_user_password(OperatorUser):
+        if self.state.shard_state.operator_password != self.state.get_user_password(
+            CharmedOperatorUser
+        ):
             return True
-        if self.state.shard_state.backup_password != self.state.get_user_password(BackupUser):
+        if self.state.shard_state.backup_password != self.state.get_user_password(
+            CharmedBackupUser
+        ):
             return True
         return False