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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mongo-charms-single-kernel
-Version: 1.8.9
+Version: 1.8.10
 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.10}/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.10"
 
 [project.urls]
 homepage = "https://github.com/canonical/mongo-single-kernel-library"

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.10}/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.10}/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.10}/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.10}/single_kernel_mongo/managers/mongodb_operator.py

@@ -100,12 +100,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,
 )
@@ -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,

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

@@ -62,9 +62,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 +108,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)),
@@ -476,8 +476,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):
@@ -637,7 +637,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 +665,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 +766,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 +893,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 +932,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
 

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.10}/single_kernel_mongo/managers/upgrade_v3.py

@@ -18,7 +18,7 @@ from single_kernel_mongo.exceptions import (
 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()
 
@@ -93,7 +93,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 +142,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 +163,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]:
@@ -400,7 +400,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 +426,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(

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.10}/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

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.10}/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)

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.10}/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",
     ]

{mongo_charms_single_kernel-1.8.9 → mongo_charms_single_kernel-1.8.10}/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}")