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

{mongo_charms_single_kernel-1.8.10 → 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.10
+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.10 → 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.10"
+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.10 → 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.10 → 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.10 → 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.10 → 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,
@@ -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
@@ -1153,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.10 → 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.10 → 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,
@@ -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:
@@ -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:

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

@@ -11,10 +11,7 @@ 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
@@ -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."
@@ -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]

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