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

single_kernel_mongo/core/operator.py

@@ -21,6 +21,8 @@ from logging import getLogger
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar, TypeAlias
 
+import charm_refresh
+import jinja2
 from data_platform_helpers.advanced_statuses.models import StatusObject
 from data_platform_helpers.advanced_statuses.protocol import ManagerStatusProtocol
 from ops.charm import RelationDepartedEvent
@@ -28,17 +30,26 @@ from ops.framework import Object
 from ops.model import Relation, Unit
 
 from single_kernel_mongo.config.literals import (
+    OS_REQUIREMENTS,
     TRUST_STORE_PATH,
     Scope,
     Substrates,
     TrustStoreFiles,
 )
-from single_kernel_mongo.config.models import CharmSpec, LogRotateConfig
+from single_kernel_mongo.config.models import SNAP_NAME, THP_CONFIG, CharmSpec, LogRotateConfig
 from single_kernel_mongo.events.ldap import LDAPEventHandler
 from single_kernel_mongo.exceptions import (
     DeferrableFailedHookChecksError,
     NonDeferrableFailedHookChecksError,
 )
+from single_kernel_mongo.lib.charms.operator_libs_linux.v0 import sysctl
+from single_kernel_mongo.lib.charms.operator_libs_linux.v1.systemd import (
+    SystemdError,
+    daemon_reload,
+    service_disable,
+    service_enable,
+    service_start,
+)
 from single_kernel_mongo.managers.config import FileBasedConfigManager
 from single_kernel_mongo.managers.mongo import MongoManager
 from single_kernel_mongo.state.charm_state import CharmState
@@ -49,10 +60,11 @@ 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.lib.charms.operator_libs_linux.v0.sysctl import Config
     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,14 +91,16 @@ 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
+    sysctl_config: Config
 
     if TYPE_CHECKING:
 
@@ -215,6 +229,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.
 
@@ -271,6 +292,17 @@ class OperatorProtocol(ABC, Object, ManagerStatusProtocol):
                     f"{path}",
                 ]
             )
+
+        if self.substrate == Substrates.VM:
+            self.workload.exec(
+                [
+                    "chown",
+                    "-R",
+                    f"{self.workload.users.user}:{self.workload.users.group}",
+                    f"{self.workload.paths.common_path}",
+                ]
+            )
+
         for path in (
             self.workload.paths.config_file,
             self.workload.paths.mongos_config_file,
@@ -305,3 +337,52 @@ class OperatorProtocol(ABC, Object, ManagerStatusProtocol):
         self.workload.exec(["update-ca-certificates"])
         # Restart the service
         self.restart_charm_services(force=True)
+
+    def write_thp_config_file(self):
+        """Writes the unit file to enable Transparent Huge Pages."""
+        data = THP_CONFIG.service_template.read_text()
+        template = jinja2.Template(data)
+
+        rendered_template = template.render(
+            service_file=f"snap.{SNAP_NAME}.{self.workload.service}.service"
+        )
+        self.workload.write(path=THP_CONFIG.service_file_path, content=rendered_template)
+        daemon_reload()
+        service_enable(THP_CONFIG.service_name)
+        service_start(THP_CONFIG.service_name)
+
+    def _set_os_config(self) -> None:
+        """Sets sysctl config for mongodb."""
+        try:
+            self.sysctl_config.configure(OS_REQUIREMENTS)
+        except (sysctl.ApplyError, sysctl.ValidationError, sysctl.CommandError) as e:
+            # we allow events to continue in the case that we are not able to correctly configure
+            # sysctl config, since we can  still run the workload with wrong sysctl parameters
+            # even if it is not optimal.
+            logger.error(f"Error setting values on sysctl parameters: {e.message}")
+            # containers share the kernel with the host system, and some sysctl parameters are
+            # set at kernel level.
+            logger.warning("sysctl params cannot be set. Is the machine running on a container?")
+        try:
+            self.write_thp_config_file()
+        except SystemdError as e:
+            # we allow events to continue in the case that we are not able to correctly configure
+            # sysctl config, since we can  still run the workload with wrong kernel parameters
+            # even if it is not optimal.
+            logger.error(f"Error setting values on kernel parameters: {e.args}")
+            # containers share the kernel with the host system, and some sysctl parameters are
+            # set at kernel level.
+            logger.warning("kernel params cannot be set. Is the machine running on a container?")
+            service_disable(THP_CONFIG.service_name)
+
+    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)

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:

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

single_kernel_mongo/core/workload.py

@@ -9,12 +9,13 @@ import string
 from abc import ABC, abstractmethod
 from itertools import chain
 from pathlib import Path
-from typing import ClassVar
+from typing import Any, ClassVar
 
+import tomllib
 from ops import Container
 from ops.pebble import Layer
 
-from single_kernel_mongo.config.literals import WorkloadUser
+from single_kernel_mongo.config.literals import VERSIONS_FILE, WorkloadUser
 from single_kernel_mongo.config.models import CharmSpec
 
 
@@ -149,7 +150,7 @@ class WorkloadBase(ABC):  # pragma: nocover
         self.role = role
 
     @abstractmethod
-    def install(self) -> None:
+    def install(self, revision: str | None = None, retry_and_raise: bool = True) -> bool:
         """Installs the workload snap or raises an error.
 
         VM-only: on k8s, just returns None.
@@ -283,6 +284,17 @@ class WorkloadBase(ABC):  # pragma: nocover
         """
         ...
 
+    def snap_revision(self) -> str:
+        """The currently installed snap_revision."""
+        return ""
+
+    def load_toml_file(self, file: Path) -> dict[str, Any]:
+        """Loads a TOML file to a dictionary."""
+        if not file.exists():
+            return {}
+
+        return tomllib.loads(file.read_text())
+
     def get_version(self) -> str:
         """Get the workload version.
 
@@ -295,21 +307,6 @@ class WorkloadBase(ABC):  # pragma: nocover
             version = ""
         return version
 
-    def get_internal_revision(self) -> str:
-        """Get the internal revision.
-
-        Note: This should be removed soon because we're moving away from `charm
-        version` + `internal revision` to `charm_version+git hash`.
-
-        Returns:
-            String of charm internal revision
-        """
-        try:
-            version = Path("charm_version").read_text().strip()
-        except:  # noqa: E722
-            version = ""
-        return version
-
     def get_charm_revision(self) -> str:
         """Get the charm revision.
 
@@ -317,7 +314,8 @@ class WorkloadBase(ABC):  # pragma: nocover
             String of charm revision
         """
         try:
-            version = Path("charm_version").read_text().strip()
+            versions = self.load_toml_file(VERSIONS_FILE)
+            version = versions["charm"]
         except:  # noqa: E722
             version = ""
         return version

single_kernel_mongo/events/backups.py

@@ -79,7 +79,7 @@ class BackupEventsHandler(Object):
 
     def _on_s3_relation_joined(self, event: RelationJoinedEvent) -> None:
         """Checks for valid integration for s3-integrations."""
-        if self.dependent.state.upgrade_in_progress:
+        if self.dependent.refresh_in_progress:
             logger.warning(
                 "Adding s3-relations is not supported during an upgrade. The charm may be in a broken, unrecoverable state."
             )
@@ -97,7 +97,7 @@ class BackupEventsHandler(Object):
 
     def _on_s3_credential_changed(self, event: CredentialsChangedEvent) -> None:  # noqa: C901
         action = "configure-pbm"
-        if self.dependent.state.upgrade_in_progress:
+        if self.dependent.refresh_in_progress:
             logger.warning(
                 "Changing s3-credentials is not supported during an upgrade. The charm may be in a broken, unrecoverable state."
             )
@@ -285,7 +285,7 @@ class BackupEventsHandler(Object):
             )
             return
 
-        if self.dependent.state.upgrade_in_progress:
+        if self.dependent.refresh_in_progress:
             fail_action_with_error_log(
                 logger,
                 event,

single_kernel_mongo/events/cluster.py

@@ -72,7 +72,7 @@ class ClusterConfigServerEventHandler(Object):
         Calls the manager to share the secrets with mongos charm.
         """
         try:
-            self.manager.share_secret_to_mongos(event.relation)
+            self.manager.share_secret_to_mongos(event.relation, initial_event=True)
         except DeferrableFailedHookChecksError as e:
             logger.info("Skipping database requested event: hook checks did not pass.")
             defer_event_with_info_log(logger, event, str(type(event)), str(e))

single_kernel_mongo/events/database.py

@@ -138,7 +138,7 @@ class DatabaseEventsHandler(Object):
         if not self.charm.unit.is_leader():
             return False
 
-        if self.dependent.state.upgrade_in_progress:
+        if self.dependent.refresh_in_progress:
             logger.warning(
                 "Adding relations is not supported during an upgrade. The charm may be in a broken, unrecoverable state."
             )

single_kernel_mongo/events/lifecycle.py

@@ -130,9 +130,10 @@ class LifecycleEventsHandler(Object):
         """Start event."""
         try:
             self.dependent.prepare_for_startup()
-        except (ContainerNotReadyError, WorkloadServiceError):
-            logger.info("Not ready to start.")
-            event.defer()
+        except (ContainerNotReadyError, WorkloadServiceError) as e:
+            defer_event_with_info_log(
+                logger, event, "start", f"Not ready to start: {e.__class__.__name__}({e})"
+            )
             return
         except InvalidConfigRoleError:
             logger.info("Missing a valid role.")
@@ -222,7 +223,7 @@ class LifecycleEventsHandler(Object):
                 secret_id=event.secret.id or "",
             )
         except (WorkloadServiceError, ChangeError) as err:
-            logger.info("Failed to restart services", err, exc_info=True)
+            logger.info("Failed to restart services: %s", err, exc_info=True)
             self.dependent.state.statuses.add(
                 CharmStatuses.FAILED_SERVICES_START.value,
                 scope="unit",

single_kernel_mongo/events/tls.py

@@ -77,7 +77,7 @@ class TLSEventsHandler(Object):
             )
             event.fail("Mongos cannot set TLS keys until integrated to config-server.")
             return
-        if self.manager.state.upgrade_in_progress:
+        if self.dependent.refresh_in_progress:
             fail_action_with_error_log(
                 logger,
                 event,
@@ -106,7 +106,8 @@ class TLSEventsHandler(Object):
             )
             event.defer()
             return
-        if self.manager.state.upgrade_in_progress:
+
+        if self.dependent.refresh_in_progress:
             logger.warning(
                 "Enabling TLS is not supported during an upgrade. The charm may be in a broken, unrecoverable state."
             )
@@ -131,7 +132,7 @@ class TLSEventsHandler(Object):
             event.defer()
             return
 
-        if self.manager.state.upgrade_in_progress:
+        if self.dependent.refresh_in_progress:
             logger.warning(
                 "Disabling TLS is not supported during an upgrade. The charm may be in a broken, unrecoverable state."
             )
@@ -162,7 +163,9 @@ class TLSEventsHandler(Object):
             logger.info(f"Deferring {str(type(event))}: db is not initialised")
             event.defer()
             return
-        if self.manager.state.upgrade_in_progress:
+        # Check if refresh is in progress and this is the initial integration, delay.
+        # Otherwise it's a rotation and we're safe to continue.
+        if self.dependent.refresh_in_progress and self.manager.initial_integration():
             logger.warning(
                 "Enabling TLS is not supported during an upgrade. The charm may be in a broken, unrecoverable state."
             )

single_kernel_mongo/exceptions.py

@@ -4,10 +4,6 @@
 
 """All general exceptions."""
 
-from data_platform_helpers.advanced_statuses.models import StatusObject
-
-from single_kernel_mongo.config.statuses import UpgradeStatuses
-
 
 class InvalidCharmKindError(Exception):
     """Raised when calling a function on the wrong charm kind."""
@@ -122,6 +118,10 @@ class UpgradeInProgressError(Exception):
     """Raised when an upgrade is in progress."""
 
 
+class MongoDBUpgradeError(Exception):
+    """Raised when the snap upgrade fails."""
+
+
 class OpenPortFailedError(Exception):
     """Raised when we fail to open ports."""
 
@@ -209,22 +209,6 @@ class EarlyRemovalOfConfigServerError(Exception):
     """Raised when we try to remove config server while it still has shards."""
 
 
-class StatusError(Exception):
-    """Exception with ops status."""
-
-    def __init__(self, status: StatusObject) -> None:
-        super().__init__(status.message)
-        self.status = status
-
-
-class PrecheckFailedError(StatusError):
-    """App is not ready to upgrade."""
-
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(UpgradeStatuses.REFRESH_IN_PROGRESS.value)
-
-
 class FailedToElectNewPrimaryError(Exception):
     """Raised when a new primary isn't elected after stepping down."""
 
@@ -249,10 +233,6 @@ class ActionFailedError(Exception):
     """Raised when we failed an action."""
 
 
-class UnhealthyUpgradeError(Exception):
-    """Raised when the upgrade is unhealthy during an post upgrade check."""
-
-
 class WaitingForLdapDataError(DeferrableError):
     """Raised when the charm hasn't received data from ldap yet."""