mongo-charms-single-kernel 1.8.9__py3-none-any.whl → 1.8.11__py3-none-any.whl

{mongo_charms_single_kernel-1.8.9.dist-info → mongo_charms_single_kernel-1.8.11.dist-info}/METADATA

@@ -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.dist-info → mongo_charms_single_kernel-1.8.11.dist-info}/RECORD

@@ -1,19 +1,19 @@
 single_kernel_mongo/__init__.py,sha256=yTtXuLHbaXGJ5IgR7PhhNOzmqlpqywkTNI4bmkNECQ4,421
 single_kernel_mongo/abstract_charm.py,sha256=x8LnydlO2hoiJBp_ijRUNrfOH1YrvpcZy5SpuYR1jdg,5762
 single_kernel_mongo/config/__init__.py,sha256=OGTmp5MZXk2ZGgElT0A1yVyQz6FB4JzjG34mbeIWG2k,128
-single_kernel_mongo/config/literals.py,sha256=OH5vzTYdDaPtyZ-Qope-cYpsdxN_GEa43ElIn_98T3Q,2113
+single_kernel_mongo/config/literals.py,sha256=4U2ODGjBRzJ2RCFJmydkBUpaoAcf4XjPOduU1fOnvu8,2181
 single_kernel_mongo/config/models.py,sha256=MruFI2EJndfH3KaJ5iaNar1oyMrTfSZaTQ3yxTxllnc,6770
 single_kernel_mongo/config/relations.py,sha256=CisZvNUNEy27_oxEme_WpmZbN7DuDGfh4EUrAeoJprw,1096
 single_kernel_mongo/config/statuses.py,sha256=hJ-BB-o85DfnRwEU-_6SGzMzebmYbDZNSvcBmHvL2hc,25761
 single_kernel_mongo/core/__init__.py,sha256=K1XAyFSIkldkT-008Eeg_o7H_XveWaxRuXGJnwoB_DU,124
-single_kernel_mongo/core/abstract_upgrades_v3.py,sha256=AU_eiZ5PU76mcJWoXcZZRaVWCTAZqLyw0RXk3J3bxbQ,5744
+single_kernel_mongo/core/abstract_upgrades_v3.py,sha256=yYmLobPTCW_vJnJxHLpcYFvhlUf1feIjGkdXRwsJFvg,6079
 single_kernel_mongo/core/k8s_workload.py,sha256=wp3plDVg6h8vfG8Zpi_p2mq_TNP_2uBlPMt0kWlWrgk,5442
 single_kernel_mongo/core/kubernetes_upgrades_v3.py,sha256=OdzU2g2m2_QI9fAzxaJKnAek5dEc9ZxQ05bgqIT7GHw,339
 single_kernel_mongo/core/machine_upgrades_v3.py,sha256=ae_ehbL_dK778qhF3YYy4BB7ir9uekKp0HIdtf_S41o,1961
-single_kernel_mongo/core/operator.py,sha256=3k5CNyvndaNMjkLYMGMajX1saVUEAxSJi98CAvzyitI,14760
+single_kernel_mongo/core/operator.py,sha256=HMinX_KEzAhIg44wWV2fQJwXGzzIIMXfAFo41JT4YvM,15040
 single_kernel_mongo/core/secrets.py,sha256=SOS19OhzpWdPur7JpggJ84u333tNyapTEgf_kjDjD6M,6755
 single_kernel_mongo/core/structured_config.py,sha256=5M2za_9Kh7_8tLLS16BcIBxU6EmtlmMqVHF-AczPDYc,4434
-single_kernel_mongo/core/version_checker.py,sha256=q8HZZUvy-h3CKxcaCtBss6UvwoexD92OaLmru6ikuJ0,3711
+single_kernel_mongo/core/version_checker.py,sha256=t5uTpNgejmFAWOZlcMzWMXJ3R_s5T3scGp_y6y7jG5g,3019
 single_kernel_mongo/core/vm_workload.py,sha256=7KUgc82DaWVaxx3UEypuLZ3AIR_dlnqDnB6sorhbArw,7043
 single_kernel_mongo/core/workload.py,sha256=EHQdsL9uLb4zREChobxa9QvlzT1a1efMLkV2wAjaBBI,10239
 single_kernel_mongo/events/__init__.py,sha256=xatr1vi0ZKdqF1X-L2vaRuz1vJHwxschJu0XYxd_zoM,126
@@ -41,17 +41,17 @@ single_kernel_mongo/lib/charms/tls_certificates_interface/v4/tls_certificates.py
 single_kernel_mongo/managers/__init__.py,sha256=EUhvtK85skMEcT3yacYwezyIW4ajsoC5SwxpZcmPZnM,145
 single_kernel_mongo/managers/backups.py,sha256=L5UrxCSoYEJI8dtWA4tikNvTo71IQJqtMamvgKxsTGQ,40176
 single_kernel_mongo/managers/cluster.py,sha256=FhqbWFuozstdXMB1cO7QYMDMguhCrGSQY-uISuZaNaM,22557
-single_kernel_mongo/managers/config.py,sha256=F4qszxKV5A8ZPlpRXFWm5xXnjRFEqM5eouSCnLP4hqQ,18609
+single_kernel_mongo/managers/config.py,sha256=5rgFw53XEDKhvJEADFmKxFa-Nv6AdPRSY5P8yh43caI,18660
 single_kernel_mongo/managers/k8s.py,sha256=I9NNaUKYlOGt6JoTa3gicqzPdO9yPWgO4tPgGBac1uQ,11036
 single_kernel_mongo/managers/ldap.py,sha256=xDyfWZWdrku1WY1phAJELPZAwynBM1Q2bXRA2gOyQto,15823
-single_kernel_mongo/managers/mongo.py,sha256=SMGion-lciKU9REzI7HTHs_R8rMafngbZzS7BfAWybc,24326
-single_kernel_mongo/managers/mongodb_operator.py,sha256=fcBSmV3ELs5x3NYhBAVN_iIYk1cwS7snP7-0mmOm8oY,56703
-single_kernel_mongo/managers/mongos_operator.py,sha256=ZVW7eIsQo0DmK4VzYruDlMsQkKL_ju4TtJkU4FXGIJo,25475
+single_kernel_mongo/managers/mongo.py,sha256=tMYGP3q04L1CFdfsiLiLeOmAixuSzcTwhTL3yXZeePw,24401
+single_kernel_mongo/managers/mongodb_operator.py,sha256=zfeOJ1CCq6kEEPOeOjeqbX3xhYXP1rFbW4MQXMaZsdc,56564
+single_kernel_mongo/managers/mongos_operator.py,sha256=nKnSgbwWROCKUNnhmlbpYhkGN20P633KUXkG8Mp-Xzc,25854
 single_kernel_mongo/managers/observability.py,sha256=j5Nt5Wv43HaYVcr2f6Y_DqHJaP5XhUMjjh7Gg8JwsZI,3584
-single_kernel_mongo/managers/sharding.py,sha256=l2HYRdziu3yHq9mS8xuH5EwQHNG9Bz4HnVwHKPw2gqs,47461
+single_kernel_mongo/managers/sharding.py,sha256=KKFktjr-j_86HRSZK4DWhuwOImhja_k8A3fAliwcTtE,47497
 single_kernel_mongo/managers/tls.py,sha256=-r0hj2b5LuHh-2Md1ask3CdICC09A5yiYzC6OjGuTpY,15834
-single_kernel_mongo/managers/upgrade_v3.py,sha256=Wci00SC1Ey599T0VefWHbfsl3nnqUVNru7RU3qJnCbY,19673
-single_kernel_mongo/managers/upgrade_v3_status.py,sha256=IRo4Geyv3mUmqy8QgnD4qWzQaTHLiGkMkKD1dC4ZZq4,5770
+single_kernel_mongo/managers/upgrade_v3.py,sha256=NL_b32yqJIN_w00DvGppyvZWgMzNemGxI3UW-tYd6wk,20990
+single_kernel_mongo/managers/upgrade_v3_status.py,sha256=Pa_-tsLVru0l36u4U3lhGE8683bWuJOGKdhAjiKkNvU,5765
 single_kernel_mongo/observability_rules/__init__.py,sha256=VuClFh0iGrw64cP4JppbSotFRyGpNVGmT8oD8pAbJoM,146
 single_kernel_mongo/observability_rules/grafana_dashboards/MongoDB_Cluster_Summary.json,sha256=z1mqwwTqot3lJogtinuCFMwecmPuInUsuOVSeHq9tj4,42626
 single_kernel_mongo/observability_rules/grafana_dashboards/MongoDB_ReplSet_Summary.json,sha256=qYyPM__vsL52jzUlC9ta9GkTZoKMZCmSN1AJoOy0wis,110603
@@ -61,11 +61,11 @@ single_kernel_mongo/observability_rules/vm_prometheus_alert_rules/percona-mongod
 single_kernel_mongo/state/__init__.py,sha256=V5TWoUtibFiyVO0BqPHnZOZrLNTIIgiVm3vmrhw8tS4,145
 single_kernel_mongo/state/abstract_state.py,sha256=2bSGXu0KehBw_XIu7THWZEVzrX6C8-73_9mlUrfEMXg,2471
 single_kernel_mongo/state/app_peer_state.py,sha256=ul2Z4EBFBm2HW58UaDFrR0mgj6cE8O5zWPzlTPRl8Cs,7501
-single_kernel_mongo/state/charm_state.py,sha256=-g-Ag5zbfmyM9-caXsE_j2xWeNb2s3P_FwUbdqNZHUY,30279
+single_kernel_mongo/state/charm_state.py,sha256=P6q7GiMzJH99434XjWlkXIGzDeNzi6wW4PY1Z-4DycI,30370
 single_kernel_mongo/state/cluster_state.py,sha256=CmtC2ztAl02K_UEzix-jnObHri72m1pplzUbO7HKLB8,3228
-single_kernel_mongo/state/config_server_state.py,sha256=u9mr_-OCuIgbadHDLNxVkzL23qigVAn84GbnSemg-yo,4109
+single_kernel_mongo/state/config_server_state.py,sha256=8gtCacXYEsw1-F968yRdaMQd6IBgbywy0qZv0XJs_kA,4155
 single_kernel_mongo/state/ldap_state.py,sha256=7XxjYoFMI8vujlqbCj5JyqigIlmYc-ebL9e0MEDW23Q,7915
-single_kernel_mongo/state/models.py,sha256=Ipfy2OdCekL1bIBr22Cb-pJiYhQdNvLIZYR4wPmc30g,592
+single_kernel_mongo/state/models.py,sha256=eZUeHWa21BPJXfkr78ra9kqcmvwtGQUcJ6iGD_4BiGQ,608
 single_kernel_mongo/state/tls_state.py,sha256=CVNvMHmsX83wgStOHwWTOqqApv9LTm4lJLQFDqoNFSQ,3413
 single_kernel_mongo/state/unit_peer_state.py,sha256=99Qn6DkKXO_y5isuLXICfrQeVg3uqy0uW_48g7WqGK0,4080
 single_kernel_mongo/templates/__init__.py,sha256=8-zJnYHONfuTjeihx1ZL34URMW6c_MwJaIMBJgoPGTc,141
@@ -78,14 +78,14 @@ single_kernel_mongo/utils/helpers.py,sha256=N99hZq9USaWdi87XU9JR2W8SP9KfdAOaJy5f
 single_kernel_mongo/utils/mongo_config.py,sha256=tU7dGUZPSWdfttUn868vi_q5y6EWvGN2SREfexM8pxU,4134
 single_kernel_mongo/utils/mongo_connection.py,sha256=330gz1Ha5WdfdfxYmci1jVRnrRswtomoukn3AASSXCU,28540
 single_kernel_mongo/utils/mongo_error_codes.py,sha256=mM_KHTR3b9UA4BaxmzSlCVrFUNhRAc458ndBvJ4fg_8,479
-single_kernel_mongo/utils/mongodb_users.py,sha256=7Ckkkuy9eYeOHpNyk291P-rpH0Flk8KKCa3gkdE3BYI,6575
+single_kernel_mongo/utils/mongodb_users.py,sha256=gPko6V244iSVhMxnCYll77azswhwLQZyzJ9RQATAg8E,6709
 single_kernel_mongo/workload/__init__.py,sha256=NCTTPCH9hbyi5pNO6UUfChpHh7h82xQ28aVAFIRlBOM,3225
 single_kernel_mongo/workload/backup_workload.py,sha256=7OugmoBE1SR3H8BUFYkIjtKv52bAk8oC2Q1CrCELOwg,1932
 single_kernel_mongo/workload/log_rotate_workload.py,sha256=VmWUJ_mqxN4v_IAFHw6lLCofUMqom24E2bFjaK12dck,3029
 single_kernel_mongo/workload/mongodb_workload.py,sha256=UHXVUQI1FyAhnP2TTLKiTFWWrUUaX-On4wDIsT5DXvQ,1527
 single_kernel_mongo/workload/mongos_workload.py,sha256=p1ZjqbGTokcxNnqKCvCIUQvmDvkOcN8pRvkPfA7Rgeg,1815
 single_kernel_mongo/workload/monitor_workload.py,sha256=dw-F3Y11_jpqI30Hg30-y6kxFFXGnHcSbgdAAJE8C8Q,1793
-mongo_charms_single_kernel-1.8.9.dist-info/METADATA,sha256=Nh_SFhIekPoSscT6kfdNC-Ui8vdQ9TeUF47jeAebrr0,5310
-mongo_charms_single_kernel-1.8.9.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-mongo_charms_single_kernel-1.8.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mongo_charms_single_kernel-1.8.9.dist-info/RECORD,,
+mongo_charms_single_kernel-1.8.11.dist-info/METADATA,sha256=_rkAURoIDKm5j4qVfPmanT8wanCloQBTjrZh1jqdyRo,5311
+mongo_charms_single_kernel-1.8.11.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+mongo_charms_single_kernel-1.8.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mongo_charms_single_kernel-1.8.11.dist-info/RECORD,,

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")
 

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(

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)

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

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()

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."""

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.
 

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:

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
 

single_kernel_mongo/managers/upgrade_v3.py

@@ -11,14 +11,11 @@ from tenacity import Retrying, retry, stop_after_attempt, wait_fixed
 from single_kernel_mongo.core.operator import OperatorProtocol
 from single_kernel_mongo.core.structured_config import MongoDBRoles
 from single_kernel_mongo.core.workload import WorkloadBase
-from single_kernel_mongo.exceptions import (
-    BalancerStillRunningError,
-    ClusterNotHealthyError,
-)
+from single_kernel_mongo.exceptions import BalancerStillRunningError, ClusterNotHealthyError
 from single_kernel_mongo.state.charm_state import CharmState
 from single_kernel_mongo.utils.mongo_config import MongoConfiguration
 from single_kernel_mongo.utils.mongo_connection import MongoConnection
-from single_kernel_mongo.utils.mongodb_users import OperatorUser
+from single_kernel_mongo.utils.mongodb_users import CharmedOperatorUser
 
 logger = logging.getLogger()
 
@@ -60,6 +57,26 @@ class MongoDBUpgradesManager:
             )
             return False
 
+    def are_shards_accessible(self) -> bool:
+        """Checks if all nodes are responsive to a simple ping, fails otherwise."""
+        mongos_config = self.get_cluster_mongos()
+        for replica_set_config in self.get_all_replica_set_configs_in_cluster(mongos_config):
+            for single_host in replica_set_config.hosts:
+                if single_host != self.state.unit_peer_data.internal_address:
+                    logger.info(f"Checking if shard {single_host} is responding to ping")
+                    single_replica_config = self.state.mongodb_config_for_user(
+                        CharmedOperatorUser,
+                        hosts={single_host},
+                        replset=replica_set_config.replset,
+                    )
+                    try:
+                        with MongoConnection(single_replica_config, direct=True) as mongod:
+                            mongod.client.admin.command("ping")
+                    except PyMongoError as e:
+                        logger.info(f"{single_host} does not respond to ping: {e}")
+                        return False
+        return True
+
     def are_nodes_healthy(self) -> bool:
         """Returns true if all nodes in the MongoDB deployment are healthy."""
         if self.state.is_sharding_component and not self.state.has_sharding_integration:
@@ -68,6 +85,9 @@ class MongoDBUpgradesManager:
             return self.are_replica_set_nodes_healthy(self.state.mongo_config)
 
         mongos_config = self.get_cluster_mongos()
+        if not self.are_shards_accessible():
+            return False
+
         if not self.are_shards_healthy(mongos_config):
             logger.info(
                 "One or more individual shards are not healthy - do not proceed with refresh."
@@ -93,7 +113,7 @@ class MongoDBUpgradesManager:
             self.state.mongos_config
             if self.state.is_role(MongoDBRoles.CONFIG_SERVER)
             else self.state.mongos_config_for_user(
-                OperatorUser, hosts=set(self.state.shard_state.mongos_hosts)
+                CharmedOperatorUser, hosts=set(self.state.shard_state.mongos_hosts)
             )
         )
 
@@ -142,7 +162,7 @@ class MongoDBUpgradesManager:
             config_server_hosts = self.state.app_peer_data.mongos_hosts
             mongodb_configurations = [
                 self.state.mongodb_config_for_user(
-                    OperatorUser,
+                    CharmedOperatorUser,
                     hosts=set(config_server_hosts),
                     replset=self.state.config_server_name,
                 )
@@ -163,7 +183,7 @@ class MongoDBUpgradesManager:
         shard_hosts = shard_entry["host"].split("/")[1]
         parsed_ips = {host.split(":")[0] for host in shard_hosts.split(",")}
         return self.state.mongodb_config_for_user(
-            OperatorUser, parsed_ips, replset=shard_entry[SHARD_NAME_INDEX]
+            CharmedOperatorUser, parsed_ips, replset=shard_entry[SHARD_NAME_INDEX]
         )
 
     def get_random_write_and_collection(self) -> tuple[str, str, str]:
@@ -242,6 +262,8 @@ class MongoDBUpgradesManager:
         secondary_config = copy.deepcopy(mongodb_config)
 
         for replica_ip in mongodb_config.hosts:
+            if replica_ip == self.state.unit_peer_data.internal_address:
+                continue
             secondary_config.hosts = {replica_ip}
             with MongoConnection(secondary_config, direct=True) as direct_secondary:
                 db = direct_secondary.client[db_name]
@@ -400,7 +422,7 @@ class MongoDBUpgradesManager:
         for replica_set_config in self.get_all_replica_set_configs_in_cluster(mongos_config):
             for single_host in replica_set_config.hosts:
                 single_replica_config = self.state.mongodb_config_for_user(
-                    OperatorUser,
+                    CharmedOperatorUser,
                     hosts={single_host},
                     replset=replica_set_config.replset,
                     standalone=True,
@@ -426,7 +448,7 @@ class MongoDBUpgradesManager:
         config = self.state.mongo_config
         for host in config.hosts:
             single_unit_config = self.state.mongodb_config_for_user(
-                OperatorUser, hosts={host}, replset=config.replset, standalone=True
+                CharmedOperatorUser, hosts={host}, replset=config.replset, standalone=True
             )
             with MongoConnection(single_unit_config) as mongod:
                 version = mongod.client.admin.command(

single_kernel_mongo/managers/upgrade_v3_status.py

@@ -10,6 +10,7 @@ from ops.model import ActiveStatus, BlockedStatus, MaintenanceStatus, StatusBase
 
 from single_kernel_mongo.config.literals import Substrates
 from single_kernel_mongo.config.statuses import CharmStatuses, UpgradeStatuses
+from single_kernel_mongo.core.operator import OperatorProtocol
 from single_kernel_mongo.core.workload import WorkloadBase
 from single_kernel_mongo.exceptions import DeployedWithoutTrustError
 from single_kernel_mongo.state.charm_state import CharmState
@@ -23,8 +24,13 @@ class MongoDBUpgradesStatusManager(ManagerStatusProtocol):
     name: str = "upgrades"
 
     def __init__(
-        self, state: CharmState, workload: WorkloadBase, refresh: charm_refresh.Common | None
+        self,
+        dependent: OperatorProtocol,
+        state: CharmState,
+        workload: WorkloadBase,
+        refresh: charm_refresh.Common | None,
     ) -> None:
+        self.dependent = dependent
         self.state = state
         self.workload = workload
         self.refresh = refresh
@@ -73,10 +79,7 @@ class MongoDBUpgradesStatusManager(ManagerStatusProtocol):
             return status_list
 
         if self.refresh.in_progress and not self.refresh.next_unit_allowed_to_refresh:
-            if not self.dependent.mongo_manager.mongod_ready():
-                status_list.append(UpgradeStatuses.HEALTH_CHECK_FAILED.value)
-            else:
-                status_list.append(UpgradeStatuses.CLUSTER_CHECK_FAILED.value)
+            status_list.append(UpgradeStatuses.HEALTH_CHECK_FAILED.value)
 
         if refresh_unit_status := self.refresh.unit_status_higher_priority:
             unit_status = self._convert_ops_status_to_advanced_status(refresh_unit_status)

single_kernel_mongo/state/charm_state.py

@@ -73,12 +73,12 @@ from single_kernel_mongo.utils.mongo_config import MongoConfiguration
 from single_kernel_mongo.utils.mongo_connection import MongoConnection
 from single_kernel_mongo.utils.mongo_error_codes import MongoErrorCodes
 from single_kernel_mongo.utils.mongodb_users import (
-    BackupUser,
+    CharmedBackupUser,
+    CharmedLogRotateUser,
+    CharmedOperatorUser,
+    CharmedStatsUser,
     InternalUsers,
-    LogRotateUser,
     MongoDBUser,
-    MonitorUser,
-    OperatorUser,
     RoleNames,
 )
 
@@ -725,35 +725,35 @@ class CharmState(Object, StatusesStateProtocol):
 
     @property
     def backup_config(self) -> MongoConfiguration:
-        """Mongo Configuration for the backup user."""
-        return self.mongodb_config_for_user(BackupUser, standalone=True)
+        """Mongo Configuration for the charmed-backup user."""
+        return self.mongodb_config_for_user(CharmedBackupUser, standalone=True)
 
     @property
-    def monitor_config(self) -> MongoConfiguration:
-        """Mongo Configuration for the monitoring user."""
-        return self.mongodb_config_for_user(MonitorUser, hosts=self.internal_hosts)
+    def stats_config(self) -> MongoConfiguration:
+        """Mongo Configuration for the charmed-stats user."""
+        return self.mongodb_config_for_user(CharmedStatsUser, hosts=self.internal_hosts)
 
     @property
     def logrotate_config(self) -> MongoConfiguration:
-        """Mongo Configuration for the logrotate user."""
-        return self.mongodb_config_for_user(LogRotateUser, standalone=True)
+        """Mongo Configuration for the charmed-logrotate user."""
+        return self.mongodb_config_for_user(CharmedLogRotateUser, standalone=True)
 
     @property
     def operator_config(self) -> MongoConfiguration:
-        """Mongo Configuration for the operator user."""
-        return self.mongodb_config_for_user(OperatorUser, hosts=self.internal_hosts)
+        """Mongo Configuration for the charmed-operator user."""
+        return self.mongodb_config_for_user(CharmedOperatorUser, hosts=self.internal_hosts)
 
     @property
     def remote_mongos_config(self) -> MongoConfiguration:
         """Mongos Configuration for the remote mongos server."""
         mongos_hosts = self.app_peer_data.mongos_hosts
-        return self.mongos_config_for_user(OperatorUser, set(mongos_hosts))
+        return self.mongos_config_for_user(CharmedOperatorUser, set(mongos_hosts))
 
     @property
     def mongos_config(self) -> MongoConfiguration:
         """Mongos Configuration for the admin mongos user."""
         if self.charm_role.name == CharmKind.MONGOD:
-            return self.mongos_config_for_user(OperatorUser, self.internal_hosts)
+            return self.mongos_config_for_user(CharmedOperatorUser, self.internal_hosts)
         username, password = self.get_user_credentials()
         database = self.app_peer_data.database
         port: int | None = MongoPorts.MONGOS_PORT.value

single_kernel_mongo/state/config_server_state.py

@@ -18,8 +18,8 @@ class AppShardingComponentKeys(str, Enum):
     """Config Server State Model for the application."""
 
     DATABASE = "database"
-    OPERATOR_PASSWORD = "operator-password"
-    BACKUP_PASSWORD = "backup-password"
+    OPERATOR_PASSWORD = "charmed-operator-password"
+    BACKUP_PASSWORD = "charmed-backup-password"
     HOST = "host"
     KEY_FILE = "key-file"
     INT_CA_SECRET = "int-ca-secret"
@@ -32,8 +32,8 @@ class AppShardingComponentKeys(str, Enum):
 
 
 SECRETS_FIELDS = [
-    "operator-password",
-    "backup-password",
+    "charmed-operator-password",
+    "charmed-backup-password",
     "key-file",
     "int-ca-secret",
     "ext-ca-secret",
@@ -93,14 +93,14 @@ class AppShardingComponentState(AbstractRelationState[Data]):
 
     @property
     def operator_password(self) -> str | None:
-        """Returns the operator password."""
+        """Returns the charmed-operator password."""
         if not self.relation:
             return None
         return self.relation_data.get(AppShardingComponentKeys.OPERATOR_PASSWORD.value, None)
 
     @property
     def backup_password(self) -> str | None:
-        """Returns the operator password."""
+        """Returns the charmed-backup password."""
         if not self.relation:
             return None
         return self.relation_data.get(AppShardingComponentKeys.BACKUP_PASSWORD.value, None)

single_kernel_mongo/state/models.py

@@ -20,7 +20,7 @@ class ConfigServerData(ProviderData, RequirerData):  # type: ignore[misc]
         "tls-ca",
         "uris",
         "key-file",
-        "operator-password",
-        "backup-password",
+        "charmed-operator-password",
+        "charmed-backup-password",
         "int-ca-secret",
     ]

single_kernel_mongo/utils/mongodb_users.py

@@ -129,14 +129,14 @@ class MongoDBUser(BaseModel):
         return self.hosts
 
 
-OperatorUser = MongoDBUser(
-    username=InternalUsernames.OPERATOR,
+CharmedOperatorUser = MongoDBUser(
+    username=InternalUsernames.CHARMED_OPERATOR,
     database_name=SystemDBS.ADMIN,
     roles={RoleNames.DEFAULT},
 )
 
-MonitorUser = MongoDBUser(
-    username=InternalUsernames.MONITOR,
+CharmedStatsUser = MongoDBUser(
+    username=InternalUsernames.CHARMED_STATS,
     database_name=SystemDBS.ADMIN,
     roles={RoleNames.MONITOR},
     privileges={
@@ -154,16 +154,16 @@ MonitorUser = MongoDBUser(
     hosts={LOCALHOST},  # MongoDB Exporter can only connect to one replica.
 )
 
-BackupUser = MongoDBUser(
-    username=InternalUsernames.BACKUP,
+CharmedBackupUser = MongoDBUser(
+    username=InternalUsernames.CHARMED_BACKUP,
     roles={RoleNames.BACKUP},
     privileges={"resource": {"anyResource": True}, "actions": ["anyAction"]},
     mongodb_role="pbmAnyAction",
     hosts={LOCALHOST},  # pbm cannot make a direct connection if multiple hosts are used
 )
 
-LogRotateUser = MongoDBUser(
-    username=InternalUsernames.LOGROTATE,
+CharmedLogRotateUser = MongoDBUser(
+    username=InternalUsernames.CHARMED_LOGROTATE,
     database_name=SystemDBS.ADMIN,
     roles={RoleNames.LOGROTATE},
     privileges={"resource": {"cluster": True}, "actions": ["logRotate"]},
@@ -172,10 +172,10 @@ LogRotateUser = MongoDBUser(
 )
 
 InternalUsers = (
-    OperatorUser,
-    BackupUser,
-    MonitorUser,
-    LogRotateUser,
+    CharmedOperatorUser,
+    CharmedBackupUser,
+    CharmedStatsUser,
+    CharmedLogRotateUser,
 )
 
 
@@ -185,14 +185,14 @@ def get_user_from_username(username: str) -> MongoDBUser:
     Raises:
         ValueError: If the username is not one of the known users.
     """
-    if username == OperatorUser.username:
-        return OperatorUser
-    if username == MonitorUser.username:
-        return MonitorUser
-    if username == BackupUser.username:
-        return BackupUser
-    if username == LogRotateUser.username:
-        return LogRotateUser
+    if username == CharmedOperatorUser.username:
+        return CharmedOperatorUser
+    if username == CharmedStatsUser.username:
+        return CharmedStatsUser
+    if username == CharmedBackupUser.username:
+        return CharmedBackupUser
+    if username == CharmedLogRotateUser.username:
+        return CharmedLogRotateUser
     raise ValueError(f"Unknown user: {username}")