mongo-charms-single-kernel 1.8.6__py3-none-any.whl → 1.8.8__py3-none-any.whl

single_kernel_mongo/core/kubernetes_upgrades.py

@@ -1,194 +0,0 @@
-#!/usr/bin/env python3
-# Copyright 2024 Canonical Ltd.
-# See LICENSE file for licensing details.
-"""Kubernetes Upgrade Code.
-
-This code is slightly different from the code which was written originally.
-It is required to deploy the application with `--trust` for this code to work
-as it has to interact with the Kubernetes StatefulSet.
-"""
-
-from __future__ import annotations
-
-from logging import getLogger
-from typing import TYPE_CHECKING
-
-from data_platform_helpers.advanced_statuses.models import StatusObject
-from lightkube.core.exceptions import ApiError
-from overrides import override
-
-from single_kernel_mongo.config.literals import CharmKind, UnitState
-from single_kernel_mongo.config.statuses import UpgradeStatuses
-from single_kernel_mongo.core.abstract_upgrades import (
-    AbstractUpgrade,
-)
-from single_kernel_mongo.exceptions import ActionFailedError, DeployedWithoutTrustError
-from single_kernel_mongo.state.upgrade_state import UnitUpgradePeerData
-from single_kernel_mongo.utils.helpers import unit_number
-
-if TYPE_CHECKING:
-    from single_kernel_mongo.core.operator import OperatorProtocol
-
-logger = getLogger()
-
-
-class KubernetesUpgrade(AbstractUpgrade):
-    """Code for Kubernetes Upgrade.
-
-    This is the implementation of Kubernetes Upgrade methods.
-    """
-
-    def __init__(self, dependent: OperatorProtocol, *args, **kwargs):
-        super().__init__(dependent, *args, **kwargs)
-
-        self.k8s_manager = self.state.k8s_manager
-        try:
-            self.k8s_manager.get_partition()
-        except ApiError as err:
-            if err.status.code == 403:
-                raise DeployedWithoutTrustError(app_name=dependent.charm.app.name)
-            raise
-
-    @override
-    def _get_unit_healthy_status(self) -> StatusObject:
-        version = self.state.unit_workload_container_version
-        if version == self.state.app_workload_container_version:
-            return UpgradeStatuses.k8s_active_upgrade(
-                self._current_versions["workload"], self._current_versions["charm"]
-            )
-
-        return UpgradeStatuses.k8s_active_upgrade(
-            self._current_versions["workload"],
-            self._current_versions["charm"],
-            outdated=True,
-        )
-
-    @property
-    def app_status(self) -> StatusObject | None:
-        """App upgrade status."""
-        if not self.is_compatible:
-            logger.info(
-                "Refresh incompatible. Rollback with `juju refresh`. "
-                "If you accept potential *data loss* and *downtime*, you can continue by running `force-refresh-start`"
-                "action on each remaining unit"
-            )
-            return UpgradeStatuses.INCOMPATIBLE_UPGRADE.value
-        return super().app_status
-
-    @property
-    def partition(self) -> int:
-        """Specifies which units should upgrade.
-
-        Unit numbers >= partition should upgrade
-        Unit numbers < partition should not upgrade
-
-        https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/#partitions
-
-        For Kubernetes, unit numbers are guaranteed to be sequential.
-        """
-        return self.k8s_manager.get_partition()
-
-    @partition.setter
-    def partition(self, value: int) -> None:
-        """Sets the partition number."""
-        self.k8s_manager.set_partition(value)
-
-    @property
-    def upgrade_resumed(self) -> bool:
-        """Whether user has resumed upgrade with Juju action."""
-        return self.partition < unit_number(self.state.units_upgrade_peer_data[0])
-
-    def _determine_partition(
-        self, units: list[UnitUpgradePeerData], from_event: bool, force: bool
-    ) -> int:
-        """Determine the new partition to use.
-
-        We get the current state of each unit, and according to `action_event`,
-        `force` and the state, we decide the new value of the partition.
-        A specific case:
-         * If we don't have action event and the upgrade_order_index is 1, we
-         return because it means we're waiting for the resume-refresh/force-refresh event to run.
-        """
-        if not self.state.upgrade_in_progress:
-            return 0
-        logger.debug(f"{self.state.unit_upgrade_peer_data.relation_data=}")
-        for upgrade_order_index, unit in enumerate(units):
-            # Note: upgrade_order_index != unit number
-            state = unit.unit_state
-            if (
-                not force and state is not UnitState.HEALTHY
-            ) or self.state.unit_workload_container_versions[
-                unit.name
-            ] != self.state.app_workload_container_version:
-                if self.dependent.name == CharmKind.MONGOD:
-                    if not from_event and upgrade_order_index == 1:
-                        # User confirmation needed to resume upgrade (i.e. upgrade second unit)
-                        return unit_number(units[0])
-                return unit_number(unit)
-        return 0
-
-    def reconcile_partition(self, *, from_event: bool = False, force: bool = False) -> str | None:  # noqa: C901
-        """If ready, lower partition to upgrade next unit.
-
-        If upgrade is not in progress, set partition to 0. (If a unit receives a stop event, it may
-        raise the partition even if an upgrade is not in progress.)
-
-        Automatically upgrades next unit if all upgraded units are healthy—except if only one unit
-        has upgraded (need manual user confirmation [via Juju action] to upgrade next unit)
-
-        Handle Juju action to:
-        - confirm first upgraded unit is healthy and resume upgrade
-        - force upgrade of next unit if 1 or more upgraded units are unhealthy
-        """
-        message: str | None = None
-        if self.dependent.name == CharmKind.MONGOD:
-            force = from_event and force
-        else:
-            force = from_event
-
-        units = self.state.units_upgrade_peer_data
-
-        partition_ = self._determine_partition(
-            units,
-            from_event,
-            force,
-        )
-        logger.debug(f"{self.partition=}, {partition_=}")
-        # Only lower the partition—do not raise it.
-        # If this method is called during the action event and then called during another event a
-        # few seconds later, `determine_partition()` could return a lower number during the action
-        # and then a higher number a few seconds later.
-        # This can cause the unit to hang.
-        # Example: If partition is lowered to 1, unit 1 begins to upgrade, and partition is set to
-        # 2 right away, the unit/Juju agent will hang
-        # Details: https://chat.charmhub.io/charmhub/pl/on8rd538ufn4idgod139skkbfr
-        # This does not address the situation where another unit > 1 restarts and sets the
-        # partition during the `stop` event, but that is unlikely to occur in the small time window
-        # that causes the unit to hang.
-        if from_event:
-            assert len(units) >= 2
-            if partition_ > unit_number(units[1]):
-                message = "Highest number unit is unhealthy. Refresh will not resume."
-                raise ActionFailedError(message)
-            if force:
-                # If a unit was unhealthy and the upgrade was forced, only
-                # the next unit will upgrade. As long as 1 or more units
-                # are unhealthy, the upgrade will need to be forced for
-                # each unit.
-
-                # Include "Attempting to" because (on Kubernetes) we only
-                # control the partition, not which units upgrade.
-                # Kubernetes may not upgrade a unit even if the partition
-                # allows it (e.g. if the charm container of a higher unit
-                # is not ready). This is also applicable `if not force`,
-                # but is unlikely to happen since all units are healthy `if
-                # not force`.
-                message = f"Attempting to refresh unit {partition_}."
-            else:
-                message = f"Refresh resumed. Unit {partition_} is refreshing next."
-        if partition_ < self.partition:
-            self.partition = partition_
-            logger.debug(
-                f"Lowered partition to {partition_} {from_event=} {force=} {self.state.upgrade_in_progress=}"
-            )
-        return message

single_kernel_mongo/core/machine_upgrades.py

@@ -1,188 +0,0 @@
-# Copyright 2024 Canonical Ltd.
-# See LICENSE file for licensing details.
-
-"""In-place upgrades on machines.
-
-Derived from specification: DA058 - In-Place Upgrades - Kubernetes v2
-(https://docs.google.com/document/d/1tLjknwHudjcHs42nzPVBNkHs98XxAOT2BXGGpP7NyEU/)
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-from data_platform_helpers.advanced_statuses.models import StatusObject
-
-from single_kernel_mongo.config.literals import SNAP, CharmKind, UnitState
-from single_kernel_mongo.config.statuses import UpgradeStatuses
-from single_kernel_mongo.core.abstract_upgrades import (
-    AbstractUpgrade,
-)
-from single_kernel_mongo.exceptions import FailedToElectNewPrimaryError
-
-if TYPE_CHECKING:
-    from single_kernel_mongo.core.operator import OperatorProtocol
-
-logger = logging.getLogger(__name__)
-
-
-class MachineUpgrade(AbstractUpgrade):
-    """In-place upgrades on machines."""
-
-    @property
-    def unit_state(self) -> UnitState | None:
-        """Returns the unit state."""
-        if (
-            self.state.unit_workload_container_version is not None
-            and self.state.unit_workload_container_version
-            != self.state.app_workload_container_version
-        ):
-            logger.debug("Unit refresh state: outdated")
-            return UnitState.OUTDATED
-        return super().unit_state
-
-    @unit_state.setter
-    def unit_state(self, value: UnitState) -> None:
-        # Super call
-        AbstractUpgrade.unit_state.fset(self, value)  # type: ignore[attr-defined]
-
-    def _get_unit_healthy_status(self) -> StatusObject:
-        if self.state.unit_workload_container_version == self.state.app_workload_container_version:
-            return UpgradeStatuses.vm_active_upgrade(
-                self._unit_workload_version,
-                self.state.unit_workload_container_version,
-                self._current_versions["charm"],
-            )
-
-        return UpgradeStatuses.vm_active_upgrade(
-            self._unit_workload_version,
-            self.state.unit_workload_container_version,
-            self._current_versions["charm"],
-            outdated=True,
-        )
-
-    @property
-    def app_status(self) -> StatusObject | None:
-        """App upgrade status."""
-        if not self.is_compatible:
-            logger.info(
-                "Refresh incompatible. Rollback with `juju refresh`. "
-                "If you accept potential *data loss* and *downtime*, you can continue by running `force-refresh-start`"
-                "action on each remaining unit"
-            )
-            return UpgradeStatuses.INCOMPATIBLE_UPGRADE.value
-        return super().app_status
-
-    @property
-    def _unit_workload_version(self) -> str | None:
-        """Installed MongoDB version for this unit."""
-        return self._current_versions["workload"]
-
-    def reconcile_partition(self, *, from_event: bool = False, force: bool = False) -> str | None:
-        """Handle Juju action to confirm first upgraded unit is healthy and resume upgrade."""
-        if from_event:
-            self.upgrade_resumed = True
-            return "Refresh resumed."
-        return None
-
-    @property
-    def upgrade_resumed(self) -> bool:
-        """Whether user has resumed upgrade with Juju action.
-
-        Reset to `False` after each `juju refresh`
-        VM-only.
-        """
-        return self.state.app_upgrade_peer_data.upgrade_resumed
-
-    @upgrade_resumed.setter
-    def upgrade_resumed(self, value: bool):
-        # Trigger peer relation_changed event even if value does not change
-        # (Needed when leader sets value to False during `ops.UpgradeCharmEvent`)
-        self.state.app_upgrade_peer_data.upgrade_resumed = value
-
-    @property
-    def authorized(self) -> bool:
-        """Whether this unit is authorized to upgrade.
-
-        Only applies to machine charm.
-
-        Raises:
-            PrecheckFailed: App is not ready to upgrade
-        """
-        assert (
-            self.state.unit_workload_container_version != self.state.app_workload_container_version
-        )
-        assert self.state.app_upgrade_peer_data.versions
-        for index, unit in enumerate(self.state.units_upgrade_peer_data):
-            # Higher number units have already upgraded
-            if unit.name == self.unit_name:
-                if index == 0:
-                    if (
-                        self.state.app_upgrade_peer_data.versions["charm"]
-                        == self._current_versions["charm"]
-                    ):
-                        # Assumes charm version uniquely identifies charm revision
-                        logger.debug("Rollback detected. Skipping pre-refresh check")
-                    else:
-                        # Run pre-upgrade check
-                        # (in case user forgot to run pre-upgrade-check action)
-                        self.pre_upgrade_check()
-                        logger.debug("Pre-refresh check after `juju refresh` successful")
-                elif index == 1 and self.dependent.name == CharmKind.MONGOD:
-                    # User confirmation needed to resume upgrade (i.e. upgrade second unit)
-                    logger.debug(f"Second unit authorized to refresh if {self.upgrade_resumed=}")
-                    return self.upgrade_resumed
-                return True
-            state = unit.unit_state
-            if (
-                self.state.unit_workload_container_versions.get(unit.name)
-                != self.state.app_workload_container_version
-                or state is not UnitState.HEALTHY
-            ):
-                # Waiting for higher number units to upgrade
-                return False
-        return False
-
-    def upgrade_unit(self, *, dependent: OperatorProtocol) -> None:
-        """Runs the upgrade procedure.
-
-        Only applies to machine charm.
-        """
-        if dependent.name == CharmKind.MONGOD:
-            # According to the MongoDB documentation, before upgrading the
-            # primary, we must ensure a safe primary re-election.
-            try:
-                if self.unit_name == dependent.primary_unit_name:  # type: ignore
-                    logger.debug("Stepping down current primary, before upgrading service...")
-                    dependent.upgrade_manager.step_down_primary_and_wait_reelection()
-            except FailedToElectNewPrimaryError:
-                # by not setting the snap revision and immediately returning, this function will be
-                # called again, and an empty re-elect a primary will occur again.
-                logger.error("Failed to reelect primary before upgrading unit.")
-                return
-
-        logger.debug(f"Upgrading {self.unit_name=}")
-        self.unit_state = UnitState.UPGRADING
-        dependent.workload.install()
-        # Start charm services if they were not running after refresh
-        dependent._configure_workloads()
-        dependent.start_charm_services()
-        if dependent.name == CharmKind.MONGOD:
-            dependent._restart_related_services()  # type: ignore[attr-defined]
-
-        self.state.unit_upgrade_peer_data.snap_revision = SNAP.revision
-        logger.debug(f"Saved {SNAP.revision} in unit databag after refresh")
-
-        self.charm.unit.set_workload_version(self.workload.get_version())
-        if dependent.name == CharmKind.MONGOD:
-            self.state.unit_upgrade_peer_data.current_revision = (
-                dependent.cross_app_version_checker.version  # type: ignore
-            )
-
-        # post upgrade check should be retried in case of failure, for this it is necessary to
-        # emit a separate event.
-        dependent.upgrade_events.post_app_upgrade_event.emit()
-
-    def save_snap_revision_after_first_install(self):
-        """Set snap revision on first install."""

single_kernel_mongo/events/upgrades.py

@@ -1,157 +0,0 @@
-#!/usr/bin/env python3
-# Copyright 2024 Canonical Ltd.
-# See LICENSE file for licensing details.
-
-"""Event handler for upgrades."""
-
-from __future__ import annotations
-
-from logging import getLogger
-from typing import TYPE_CHECKING
-
-from ops.charm import ActionEvent, RelationCreatedEvent, UpgradeCharmEvent
-from ops.framework import EventBase, EventSource, Object
-from ops.model import ModelError
-
-from single_kernel_mongo.config.literals import CharmKind
-from single_kernel_mongo.config.relations import RelationNames
-from single_kernel_mongo.config.statuses import UpgradeStatuses
-from single_kernel_mongo.core.abstract_upgrades import UpgradeActions
-from single_kernel_mongo.exceptions import (
-    ActionFailedError,
-    DeferrableError,
-    UnhealthyUpgradeError,
-)
-from single_kernel_mongo.managers.upgrade import ROLLBACK_INSTRUCTIONS
-from single_kernel_mongo.utils.event_helpers import defer_event_with_info_log
-
-if TYPE_CHECKING:
-    from single_kernel_mongo.abstract_charm import AbstractMongoCharm
-    from single_kernel_mongo.core.operator import OperatorProtocol
-
-
-logger = getLogger(__name__)
-
-
-class _PostUpgradeCheckMongoDB(EventBase):
-    """Run post upgrade check on MongoDB to verify that the cluster is healhty."""
-
-
-class UpgradeEventHandler(Object):
-    """Handler for upgrade related events."""
-
-    post_app_upgrade_event = EventSource(_PostUpgradeCheckMongoDB)
-    post_cluster_upgrade_event = EventSource(_PostUpgradeCheckMongoDB)
-
-    def __init__(self, dependent: OperatorProtocol):
-        self.dependent = dependent
-        self.manager = self.dependent.upgrade_manager
-        self.charm: AbstractMongoCharm = dependent.charm
-        self.relation_name = RelationNames.UPGRADE_VERSION.value
-        super().__init__(parent=dependent, key=self.relation_name)
-
-        self.framework.observe(
-            self.charm.on[UpgradeActions.PRECHECK_ACTION_NAME].action,
-            self._on_pre_upgrade_check_action,
-        )
-
-        self.framework.observe(
-            self.charm.on[self.relation_name].relation_created,
-            self._on_upgrade_peer_relation_created,
-        )
-        self.framework.observe(
-            self.charm.on[self.relation_name].relation_changed, self._reconcile_upgrade
-        )
-        self.framework.observe(self.charm.on.upgrade_charm, self._on_upgrade_charm)
-        self.framework.observe(
-            self.charm.on[UpgradeActions.FORCE_REFRESH_START].action,
-            self._on_force_upgrade_action,
-        )
-        self.framework.observe(self.post_app_upgrade_event, self._run_post_app_upgrade_task)
-
-        if self.dependent.name == CharmKind.MONGOD:
-            self.framework.observe(
-                self.charm.on[UpgradeActions.RESUME_ACTION_NAME].action,
-                self._on_resume_upgrade_action,
-            )
-            self.framework.observe(
-                self.post_cluster_upgrade_event, self._run_post_cluster_upgrade_task
-            )
-
-    def _on_pre_upgrade_check_action(self, event: ActionEvent):
-        try:
-            self.manager.run_pre_refresh_checks()
-            event.set_results({"result": "Charm is ready for refresh."})
-        except ActionFailedError as e:
-            logger.debug(f"Pre-refresh check failed: {e}")
-            event.fail(str(e))
-
-    def _on_upgrade_peer_relation_created(self, event: RelationCreatedEvent) -> None:
-        # We have to catch a possible ModelError here.
-        # TODO: remove try/catch when https://bugs.launchpad.net/juju/+bug/2093129 is fixed.
-        try:
-            self.manager.store_initial_revisions()
-        except ModelError as err:
-            logger.info(f"Deferring because of model error: {err}")
-            event.defer()
-
-    def _reconcile_upgrade(self, _) -> None:
-        self.manager._reconcile_upgrade(during_upgrade=True)
-
-    def _on_upgrade_charm(self, event: UpgradeCharmEvent) -> None:
-        try:
-            self.manager.upgrade_charm()
-        except DeferrableError as err:
-            logger.info(f"Deferring upgrade because of {err}")
-            event.defer()
-
-    def _on_resume_upgrade_action(self, event: ActionEvent) -> None:
-        try:
-            force: bool = event.params.get("force", False)
-            message = self.manager.resume_upgrade(force=force)
-            event.set_results({"result": message})
-        except ActionFailedError as e:
-            logger.debug(f"Resume refresh failed: {e}")
-            event.fail(str(e))
-
-    def _on_force_upgrade_action(self, event: ActionEvent) -> None:
-        try:
-            message = self.manager.force_upgrade(event)
-            event.set_results({"result": message})
-        except ActionFailedError as e:
-            logger.debug(f"Resume refresh failed: {e}")
-            event.fail(str(e))
-
-    def _run_post_app_upgrade_task(self, event: _PostUpgradeCheckMongoDB) -> None:
-        try:
-            self.manager.run_post_app_upgrade_task()
-        except DeferrableError as e:
-            logger.info(ROLLBACK_INSTRUCTIONS)
-            defer_event_with_info_log(logger, event, "post cluster upgrade checks", str(e))
-        except UnhealthyUpgradeError:
-            logger.info(ROLLBACK_INSTRUCTIONS)
-            self.manager.state.statuses.add(
-                UpgradeStatuses.UNHEALTHY_UPGRADE.value,
-                scope="unit",
-                component=self.manager.name,
-            )
-            event.defer()
-
-    def _run_post_cluster_upgrade_task(self, event: _PostUpgradeCheckMongoDB) -> None:
-        """Runs after a sharded cluster has been upgraded.
-
-        It is necessary to check that the entire cluster is healthy.
-        """
-        try:
-            self.manager.run_post_cluster_upgrade_task()
-        except DeferrableError as e:
-            logger.info(ROLLBACK_INSTRUCTIONS)
-            defer_event_with_info_log(logger, event, "post cluster upgrade checks", str(e))
-        except UnhealthyUpgradeError:
-            logger.info(ROLLBACK_INSTRUCTIONS)
-            self.manager.state.statuses.add(
-                UpgradeStatuses.UNHEALTHY_UPGRADE.value,
-                scope="unit",
-                component=self.manager.name,
-            )
-            event.defer()