mongo-charms-single-kernel 1.8.6__tar.gz → 1.8.7__tar.gz

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mongo-charms-single-kernel
-Version: 1.8.6
+Version: 1.8.7
 Summary: Shared and reusable code for Mongo-related charms
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -12,6 +12,7 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
 Classifier: Operating System :: POSIX :: Linux
 Requires-Dist: boto3 (>=1.37.12,<1.38.0)
+Requires-Dist: charm-refresh (>=3.1.0.2,<4.0.0.0)
 Requires-Dist: cosl
 Requires-Dist: cryptography
 Requires-Dist: dacite (>=1.9.0,<1.10.0)

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/pyproject.toml

@@ -37,9 +37,10 @@ dependencies = [
     "deepmerge (>=2.0)",
     "boto3 (~=1.37.12)",
     "mypy-boto3-s3 (~=1.37.0)",
-    "python-ldap"
+    "python-ldap",
+    "charm-refresh (>=3.1.0.2,<4.0.0.0)",
 ]
-version = "1.8.6"
+version = "1.8.7"
 
 [project.urls]
 homepage = "https://github.com/canonical/mongo-single-kernel-library"
@@ -136,6 +137,12 @@ httpx = "*"
 boto3 = "^1.37.12"
 mypy-boto3-s3 = "^1.37.0"
 
+[tool.poetry.group.build-refresh-version]
+optional = true
+
+[tool.poetry.group.build-refresh-version.dependencies]
+charm-refresh-build-version = "^0.4.0"
+
 [tool.ruff]
 target-version = "py310"
 line-length = 100

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/single_kernel_mongo/abstract_charm.py

@@ -26,6 +26,7 @@ a DB Engine and storage), and the main peer relation name will be
 import logging
 from typing import ClassVar, Generic, TypeVar
 
+import ops.log
 from data_platform_helpers.advanced_statuses.handler import StatusHandler
 from data_platform_helpers.advanced_statuses.models import StatusObject
 from data_platform_helpers.advanced_statuses.protocol import ManagerStatusProtocol
@@ -43,6 +44,8 @@ T = TypeVar("T", bound=MongoConfigModel)
 U = TypeVar("U", bound=OperatorProtocol)
 
 logger = logging.getLogger(__name__)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
 
 
 class AbstractMongoCharm(ManagerStatusProtocol, Generic[T, U], CharmBase):
@@ -69,6 +72,11 @@ class AbstractMongoCharm(ManagerStatusProtocol, Generic[T, U], CharmBase):
         # Init the Juju object Object
         super(Generic, self).__init__(*args)
 
+        root_logger = logging.getLogger()
+        for handler in root_logger.handlers:
+            if isinstance(handler, ops.log.JujuLogHandler):
+                handler.setFormatter(logging.Formatter("{name}:{message}", style="{"))
+
         # Create the operator instance (one of MongoDBOperator or MongosOperator)
         self.operator = self.operator_type(self)
         self.state = self.operator.state

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/single_kernel_mongo/config/literals.py

@@ -50,28 +50,9 @@ class InternalUsernames(str, Enum):
     LOGROTATE = "logrotate"
 
 
-class UnitState(str, Enum):
-    """Unit upgrade state."""
-
-    HEALTHY = "healthy"
-    RESTARTING = "restarting"  # Kubernetes only
-    UPGRADING = "upgrading"  # Machines only
-    OUTDATED = "outdated"  # Machines only
-
-
 SECRETS_APP = [f"{user}-password" for user in InternalUsernames] + ["keyfile"]
 
-
-@dataclass(frozen=True)
-class Snap:
-    """The Snap related information."""
-
-    name: str = "charmed-mongodb"
-    channel: str = "8/edge"
-    revision: str = "133"
-
-
-SNAP = Snap(channel="8/edge", revision="133")
+VERSIONS_FILE = Path("refresh_versions.toml")
 
 T = TypeVar("T", bound=str | int)
 

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/single_kernel_mongo/config/relations.py

@@ -23,7 +23,6 @@ class RelationNames(str, Enum):
     CONFIG_SERVER = "config-server"
     CLUSTER = "cluster"
     MONGOS_PROXY = "mongos_proxy"
-    UPGRADE_VERSION = "upgrade-version-a"
 
 
 class Scopes(str, Enum):

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/single_kernel_mongo/config/statuses.py

@@ -139,16 +139,16 @@ class MongosStatuses(Enum):
         check="Relation validation failed.",
         action="Verify the certificates relations. Use the same CA for all cluster components.",
     )
-
-    # Running statuses:
+    MONGOS_NOT_STARTED = StatusObject(status="waiting", message="Waiting to start mongos...")
     MISSING_CONF_SERVER_REL = StatusObject(
         status="blocked",
         message="The cluster relation with the config-server is missing.",
         short_message="Missing cluster relation.",
         check="Relation validation failed.",
         action="Add the cluster relation (config-server interface) to mongos.",
-        running="async",
     )
+
+    # Running statuses:
     STARTING_MONGOS = StatusObject(
         status="maintenance", message="Starting mongos.", running="blocking"
     )
@@ -437,66 +437,19 @@ class UpgradeStatuses(Enum):
     """Upgrade statuses."""
 
     ACTIVE_IDLE = StatusObject(status="active", message="")
-    WAITING_POST_UPGRADE_STATUS = StatusObject(
-        status="waiting", message="Waiting for post upgrade checks..."
-    )
-    UNHEALTHY_UPGRADE = StatusObject(
-        status="blocked",
-        message="Unhealthy after refresh. Rollback to previous revision with `juju refresh`.",
-        approved_critical_component=True,
-    )
-    INCOMPATIBLE_UPGRADE = StatusObject(
-        status="blocked",
-        message="Refresh incompatible. Rollback to previous revision with `juju refresh`.",
+    HEALTH_CHECK_FAILED = StatusObject(
+        status="maintenance",
+        message="MongoDB is not running after upgrade",
+        action="check logs for extra information.",
         approved_critical_component=True,
     )
-    REFRESH_IN_PROGRESS = StatusObject(
+    CLUSTER_CHECK_FAILED = StatusObject(
         status="maintenance",
-        message="Refreshing...",
-        action="To rollback, run `juju refresh` to the previous revision.",
+        message="Cluster is not healthy after upgrade",
+        action="check logs for extra information.",
         approved_critical_component=True,
     )
 
-    @staticmethod
-    def vm_active_upgrade(
-        unit_workload_version: str | None,
-        unit_workload_container_version: str | None,
-        current_versions: str,
-        outdated: bool = False,
-    ) -> StatusObject:
-        """Returns the active status for a vm unit."""
-        outdated_str = " (outdated)" if outdated else ""
-        return StatusObject(
-            status="active",
-            message=f"MongoDB {unit_workload_version} running; "
-            f"Snap revision {unit_workload_container_version}{outdated_str}; "
-            f"Charm revision {current_versions}.",
-            approved_critical_component=True,
-        )
-
-    @staticmethod
-    def k8s_active_upgrade(
-        workload_version: str, charm_version: str, outdated=False
-    ) -> StatusObject:
-        """Returns the active status for a k8s unit."""
-        outdated_str = " (restart pending)" if outdated else ""
-        return StatusObject(
-            status="active",
-            message=f"MongoDB {workload_version} running{outdated_str};  Charm revision {charm_version}.",
-            approved_critical_component=True,
-        )
-
-    @staticmethod
-    def refreshing_needs_resume(
-        resume_string: str,
-    ) -> StatusObject:
-        """Returns refreshing status."""
-        return StatusObject(
-            status="blocked",
-            message=f"Refreshing. {resume_string}To rollback, `juju refresh` to last revision.",
-            approved_critical_component=True,
-        )
-
 
 class LdapStatuses(Enum):
     """Ldap Statuses."""

mongo_charms_single_kernel-1.8.7/single_kernel_mongo/core/abstract_upgrades_v3.py

@@ -0,0 +1,149 @@
+"""Common code for upgrades."""
+
+import abc
+import dataclasses
+import logging
+
+import charm_refresh
+import poetry.core.constraints.version as poetry_version
+from tenacity import RetryError
+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.managers.upgrade_v3 import MongoDBUpgradesManager
+from single_kernel_mongo.state.charm_state import CharmState
+
+logger = logging.getLogger()
+
+
+@dataclasses.dataclass(eq=False)
+class MongoDBRefresh(charm_refresh.CharmSpecificCommon, abc.ABC):
+    """Common code for MongoDB Refreshes."""
+
+    dependent: OperatorProtocol
+    upgrades_manager: MongoDBUpgradesManager
+    state: CharmState
+
+    @classmethod
+    @override
+    def is_compatible(
+        cls,
+        *,
+        old_charm_version: charm_refresh.CharmVersion,
+        new_charm_version: charm_refresh.CharmVersion,
+        old_workload_version: str,
+        new_workload_version: str,
+    ) -> bool:
+        # Check charm version compatibility
+        if not super().is_compatible(
+            old_charm_version=old_charm_version,
+            new_charm_version=new_charm_version,
+            old_workload_version=old_workload_version,
+            new_workload_version=new_workload_version,
+        ):
+            return False
+        return cls.is_workload_compatible(
+            old_workload_version=old_workload_version, new_workload_version=new_workload_version
+        )
+
+    @staticmethod
+    def is_workload_compatible(
+        old_workload_version: str,
+        new_workload_version: str,
+    ) -> bool:
+        """Check if the workload versions are compatible.
+
+        This method is called on the new charm code version. This means that it is responsible for
+        determining which versions the charm code supports refreshing from - not refreshing to.
+        """
+        try:
+            old_version = poetry_version.Version.parse(old_workload_version)
+            new_version = poetry_version.Version.parse(new_workload_version)
+        except ValueError:
+            # Not enough values to unpack or cannot convert
+            logger.error(
+                "Unable to parse workload versions."
+                f"Got {old_workload_version} to {new_workload_version}"
+            )
+            return False
+
+        if old_version.major != new_version.major:
+            logger.info(
+                "Refreshing to a different major version workload is not supported. "
+                f"Got {old_version.major} to {new_version.major}"
+            )
+            return False
+
+        if old_version > new_version:
+            logger.info(
+                "Refreshing to an older minor version workload is not supported. "
+                f"Got {old_version} to {new_version}"
+            )
+            return False
+
+        return True
+
+    def _mongodb_checks(self) -> None:
+        """MongoDB specific checks."""
+        try:
+            self.upgrades_manager.wait_for_cluster_healthy()
+        except RetryError as e:
+            logger.error(
+                "Cannot proceed with refresh. Failed to check cluster health, error: %s", e
+            )
+            raise charm_refresh.PrecheckFailed("Cluster is not healthy")
+
+        try:
+            self.upgrades_manager.move_primary_to_last_upgrade_unit()
+        except FailedToMovePrimaryError:
+            logger.error("Cluster failed to move primary before re-election.")
+            raise charm_refresh.PrecheckFailed("Primary switchover failed")
+
+        if not self.upgrades_manager.is_cluster_able_to_read_write():
+            logger.error("Cluster cannot read/write to replicas")
+            raise charm_refresh.PrecheckFailed("Cluster is not able to read/write to replicas")
+
+        fcv = self.state.app_peer_data.feature_compatibility_version
+        if not self.upgrades_manager.is_feature_compatibility_version(fcv):
+            logger.info(
+                "Not all replicas have the expected feature compatibility: %s",
+                fcv,
+            )
+            raise charm_refresh.PrecheckFailed(f"Not all replicas have the expected FCV {fcv}.")
+
+    def run_pre_refresh_checks_after_1_unit_refreshed(self):
+        """Implement pre-refresh checks."""
+        if not self.state.db_initialised:
+            return
+
+        if self.dependent.name == CharmKind.MONGOS:
+            if not self.upgrades_manager.is_mongos_able_to_read_write():
+                raise charm_refresh.PrecheckFailed("mongos is not able to read/write")
+            return
+
+        backup_state = self.dependent.backup_manager.backup_state()
+
+        if backup_state == BackupState.BACKUP_RUNNING:
+            raise charm_refresh.PrecheckFailed("Backup in progress.")
+        if backup_state == BackupState.RESTORE_RUNNING:
+            raise charm_refresh.PrecheckFailed("Restore in progress.")
+
+        self._mongodb_checks()
+
+        if not self.upgrades_manager.are_pre_upgrade_operations_config_server_successful():
+            raise charm_refresh.PrecheckFailed("Failed to disabled balancer.")
+
+    def run_pre_refresh_checks_before_any_units_refreshed(self):
+        """Runs before the upgrade."""
+        if not self.state.db_initialised:
+            return
+        if self.dependent.name == CharmKind.MONGOD:
+            if not self.dependent.mongo_manager.mongod_ready():
+                logger.error("Cannot proceed with refresh. Service mongod is not running.")
+                raise charm_refresh.PrecheckFailed("mongod is not running")
+        self.run_pre_refresh_checks_after_1_unit_refreshed()

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/single_kernel_mongo/core/k8s_workload.py

@@ -39,8 +39,8 @@ class KubernetesWorkload(WorkloadBase):
         return self.container.can_connect()
 
     @override
-    def install(self) -> None:
-        return None
+    def install(self, revision: str | None = None, retry_and_raise: bool = True) -> bool:
+        return True
 
     @override
     def start(self) -> None:

mongo_charms_single_kernel-1.8.7/single_kernel_mongo/core/kubernetes_upgrades_v3.py

@@ -0,0 +1,17 @@
+"""Kubernetes code for upgrades."""
+
+import dataclasses
+
+import charm_refresh
+
+from single_kernel_mongo.core.abstract_upgrades_v3 import MongoDBRefresh
+
+
+@dataclasses.dataclass(eq=False)
+class KubernetesMongoDBRefresh(
+    MongoDBRefresh,
+    charm_refresh.CharmSpecificKubernetes,
+):
+    """Kubernetes specific refresh code."""
+
+    pass

mongo_charms_single_kernel-1.8.7/single_kernel_mongo/core/machine_upgrades_v3.py

@@ -0,0 +1,54 @@
+"""Machine code for upgrades."""
+
+import dataclasses
+import logging
+
+import charm_refresh
+
+from single_kernel_mongo.config.literals import CharmKind
+from single_kernel_mongo.core.abstract_upgrades_v3 import MongoDBRefresh
+from single_kernel_mongo.exceptions import FailedToElectNewPrimaryError, MongoDBUpgradeError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass(eq=False)
+class MachineMongoDBRefresh(
+    MongoDBRefresh,
+    charm_refresh.CharmSpecificMachines,
+):
+    """Machine specific refresh code."""
+
+    def refresh_snap(
+        self, *, snap_name: str, snap_revision: str, refresh: charm_refresh.Machines
+    ) -> None:
+        """Refreshes a snap."""
+        self.dependent.stop_charm_services()
+
+        if self.dependent.name == CharmKind.MONGOD:
+            try:
+                if self.dependent.charm.unit.name == self.dependent.primary_unit_name:
+                    self.dependent.mongo_manager.step_down_primary_and_wait_reelection()
+            except FailedToElectNewPrimaryError:
+                logger.error("Failed to reelect primary before upgrading unit.")
+                return
+
+        revision_before_refresh = self.dependent.workload.snap_revision()
+        assert (
+            snap_revision != revision_before_refresh
+        ), "current snap revision and target revision are equal"
+
+        logger.info("Updating snap installation")
+        if not self.dependent.workload.install(revision=snap_revision, retry_and_raise=False):
+            logger.exception("Snap refresh failed")
+
+            if self.charm.workload.snap_revision() == revision_before_refresh:
+                self.dependent.start_charm_services()
+            else:
+                refresh.update_snap_revision()
+
+            # Ensures that the unit receives another juju event.
+            raise MongoDBUpgradeError("Snap Refresh failed.")
+
+        refresh.update_snap_revision()
+        logger.info(f"Updated snap to revision {snap_revision}")

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/single_kernel_mongo/core/operator.py

@@ -21,6 +21,7 @@ from logging import getLogger
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar, TypeAlias
 
+import charm_refresh
 from data_platform_helpers.advanced_statuses.models import StatusObject
 from data_platform_helpers.advanced_statuses.protocol import ManagerStatusProtocol
 from ops.charm import RelationDepartedEvent
@@ -49,10 +50,10 @@ if TYPE_CHECKING:
     from single_kernel_mongo.abstract_charm import AbstractMongoCharm
     from single_kernel_mongo.events.database import DatabaseEventsHandler
     from single_kernel_mongo.events.tls import TLSEventsHandler
-    from single_kernel_mongo.events.upgrades import UpgradeEventHandler
     from single_kernel_mongo.managers.ldap import LDAPManager
     from single_kernel_mongo.managers.tls import TLSManager
-    from single_kernel_mongo.managers.upgrade import MongoUpgradeManager
+    from single_kernel_mongo.managers.upgrade_v3 import MongoDBUpgradesManager
+    from single_kernel_mongo.managers.upgrade_v3_status import MongoDBUpgradesStatusManager
 
 logger = getLogger(__name__)
 
@@ -79,13 +80,14 @@ class OperatorProtocol(ABC, Object, ManagerStatusProtocol):
     config_manager: FileBasedConfigManager
     tls_manager: TLSManager
     state: CharmState
+    refresh: charm_refresh.Common | None
     mongo_manager: MongoManager
-    upgrade_manager: MongoUpgradeManager
+    upgrades_manager: MongoDBUpgradesManager
+    upgrades_status_manager: MongoDBUpgradesStatusManager
     ldap_manager: LDAPManager
     workload: MainWorkloadType
     client_events: DatabaseEventsHandler
     tls_events: TLSEventsHandler
-    upgrade_events: UpgradeEventHandler
     ldap_events: LDAPEventHandler
 
     if TYPE_CHECKING:
@@ -215,6 +217,13 @@ class OperatorProtocol(ABC, Object, ManagerStatusProtocol):
                 "Scaling down the application, no need to process removed relation in broken hook."
             )
 
+    @property
+    def refresh_in_progress(self) -> bool:
+        """Check if charm-refresh is currently in progress."""
+        # If charm_refresh.UnitTearDown or charm_refresh.PeerRelationNotReady
+        # we consider a refresh to be in progress.
+        return not self.refresh or self.refresh.in_progress
+
     def handle_licenses(self) -> None:
         """Pull / Push licenses.
 
@@ -305,3 +314,15 @@ class OperatorProtocol(ABC, Object, ManagerStatusProtocol):
         self.workload.exec(["update-ca-certificates"])
         # Restart the service
         self.restart_charm_services(force=True)
+
+    def build_local_tls_directory(self) -> None:
+        """On Kubernetes, we need the local configuration directory.
+
+        This will store the certificates locally, which allows to construct the
+        same URIS to connect locally and on the sidecar container running
+        mongodb.
+        """
+        if self.substrate == Substrates.VM:
+            return
+
+        Path(self.state.paths.conf_path).mkdir(exist_ok=True)

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/single_kernel_mongo/core/version_checker.py

@@ -36,19 +36,20 @@ class VersionChecker:
         # revision  88 and a config-server running on revision 110
         current_charms_version = get_charm_revision(
             self.charm.unit,
-            local_version=self.dependent.workload.get_internal_revision(),
+            local_version=self.dependent.workload.get_charm_revision(),
         )
         local_identifier = (
             "-locally built" if self.version_checker.is_local_charm(self.charm.app.name) else ""
         )
         try:
-            # This part needs some explanation: If we are running this during
-            # the pre-refresh hook that happens after the upgrade, we want to
-            # check our version against the already upgraded config server, so
+            # 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 the charm is fully upgraded.
+            # former charm until that unit is fully upgraded.
             old_version = self.version_checker.version
-            self.version_checker.version = self.state.unit_upgrade_peer_data.current_revision
+            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:

{mongo_charms_single_kernel-1.8.6 → mongo_charms_single_kernel-1.8.7}/single_kernel_mongo/core/vm_workload.py

@@ -9,18 +9,18 @@ from collections.abc import Mapping
 from itertools import chain
 from logging import getLogger
 from pathlib import Path
+from platform import machine
 from shutil import copyfile
 
 from ops import Container
-from tenacity import retry, retry_if_result, stop_after_attempt, wait_fixed
+from tenacity import retry, retry_if_exception_type, retry_if_result, stop_after_attempt, wait_fixed
 from typing_extensions import override
 
 from single_kernel_mongo.config.literals import (
     CRON_FILE,
-    SNAP,
     VmUser,
 )
-from single_kernel_mongo.config.models import CharmSpec
+from single_kernel_mongo.config.models import SNAP_NAME, CharmSpec
 from single_kernel_mongo.core.workload import WorkloadBase
 from single_kernel_mongo.exceptions import (
     WorkloadExecError,
@@ -41,8 +41,7 @@ class VMWorkload(WorkloadBase):
 
     def __init__(self, role: CharmSpec, container: Container | None) -> None:
         super().__init__(role, container)
-        self.snap = SNAP
-        self.mongod_snap = snap.SnapCache()[self.snap.name]
+        self.mongod_snap = snap.SnapCache()[SNAP_NAME]
 
     @property
     @override
@@ -186,23 +185,41 @@ class VMWorkload(WorkloadBase):
         stop=stop_after_attempt(20),
         wait=wait_fixed(1),
         reraise=True,
+        retry=retry_if_exception_type(WorkloadServiceError),
     )
-    def install(self) -> None:
-        """Loads the MongoDB snap from LP.
+    def install(self, revision: str | None = None, retry_and_raise: bool = True) -> bool:
+        """Install the charmed-mongodb snap from the snap store.
+
+        Args:
+            revision (str | None): the snap revision to install. Will be loaded from the
+                `refresh_versions.toml` file if None.
+            retry_and_raise (bool): whether to retry in case of errors. Will raise if the error
+                persists.
 
         Returns:
-            True if successfully installed. False otherwise.
+            True if successfully installed, False if errors occur and `retry_and_raise` is False.
         """
         try:
+            if not revision:
+                versions = self.load_toml_file(Path("refresh_versions.toml"))
+                revision = versions["snap"]["revisions"][machine()]
+
             self.mongod_snap.ensure(
-                snap.SnapState.Latest,
-                channel=self.snap.channel,
-                revision=self.snap.revision,
+                snap.SnapState.Present,
+                revision=revision,
             )
             self.mongod_snap.hold()
+            return True
         except snap.SnapError as err:
-            logger.error(f"Failed to install {self.snap.name}. Reason: {err}.")
-            raise WorkloadNotReadyError("Failed to install mongodb")
+            logger.error(f"Failed to install {SNAP_NAME}. Reason: {err}.")
+            if retry_and_raise:
+                raise WorkloadNotReadyError("Failed to install mongodb")
+            return False
+
+    @override
+    def snap_revision(self) -> str:
+        """The currently installed snap_revision."""
+        return self.mongod_snap.revision
 
     @override
     def setup_cron(self, lines: list[str]) -> None:  # pragma: nocover