diff --git a/pyproject.toml b/pyproject.toml index f776b996..66986108 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ [project] name = "postgresql-charms-single-kernel" description = "Shared and reusable code for PostgreSQL-related charms" -version = "16.3.25" +version = "16.3.26" readme = "README.md" license = {file = "LICENSE"} authors = [ @@ -40,7 +40,7 @@ postgresql = [ vm = [ "pysyncobj>=0.3.15; python_version >= '3.12'", "psutil>=7.2.2; python_version >= '3.12'", - "charmlibs-snap>=1.0.1,<2; python_version >= '3.12'", + "charmlibs-snap>=2.0.0,<3; python_version >= '3.12'", "charmlibs-systemd>=1.0.0.post0; python_version >= '3.12'", "cosl>=0.0.53; python_version >= '3.12'", ] diff --git a/single_kernel_postgresql/charms/vm_charm.py b/single_kernel_postgresql/charms/vm_charm.py index cd77ebb5..c053b5e3 100755 --- a/single_kernel_postgresql/charms/vm_charm.py +++ b/single_kernel_postgresql/charms/vm_charm.py @@ -50,6 +50,7 @@ from single_kernel_postgresql.utils.postgresql import ( PostgreSQL as PostgreSQLClient, ) +from single_kernel_postgresql.utils.snap import service_states from single_kernel_postgresql.utils.tracing import charm_tracing_config from single_kernel_postgresql.workload.vm import VMWorkload @@ -240,86 +241,82 @@ def request_restart(self) -> None: def restart_services(self) -> None: """Restart the monitoring and LDAP sync snap services if needed (port).""" - cache = snap.SnapCache() - postgres_snap = cache[charm_refresh.snap_name()] - self._restart_metrics_service(postgres_snap) - self._restart_ldap_sync_service(postgres_snap) + snap_name = charm_refresh.snap_name() + self._restart_metrics_service(snap_name=snap_name) + self._restart_ldap_sync_service(snap_name=snap_name) - def _restart_metrics_service(self, postgres_snap: snap.Snap) -> None: + def _restart_metrics_service(self, snap_name: str) -> None: """Restart the monitoring service if the password was rotated (port).""" try: - snap_password = postgres_snap.get("exporter.password") - except snap.SnapError: + snap_password = snap.get_one(snap_name, "exporter.password") + except snap.Error: logger.warning("Early exit: Trying to reset metrics service with no configuration set") return None if snap_password != self.state.get_secret(APP_SCOPE, MONITORING_PASSWORD_KEY): - self._setup_exporter(postgres_snap) + self._setup_exporter(snap_name=snap_name) - def _restart_ldap_sync_service(self, postgres_snap: snap.Snap) -> None: + def _restart_ldap_sync_service(self, snap_name: str) -> None: """Restart the LDAP sync service in case any configuration changed (port).""" if not self.patroni_manager.member_started: logger.debug("Restart LDAP sync early exit: Patroni has not started yet") return - sync_service = postgres_snap.services["ldap-sync"] + sync_service = service_states(snap_name)["ldap-sync"] - if not self.is_primary and sync_service["active"]: + if not self.is_primary and sync_service: logger.debug("Stopping LDAP sync service. It must only run in the primary") - postgres_snap.stop(services=["ldap-sync"]) + snap.stop(snap_name, services=["ldap-sync"]) if self.is_primary and not self.is_ldap_enabled: logger.debug("Stopping LDAP sync service") - postgres_snap.stop(services=["ldap-sync"]) + snap.stop(snap_name, services=["ldap-sync"]) return if self.is_primary and self.is_ldap_enabled: - self._setup_ldap_sync(postgres_snap) + self._setup_ldap_sync(snap_name=snap_name) - def _setup_exporter(self, postgres_snap: snap.Snap | None = None) -> None: + def _setup_exporter(self, snap_name: str | None = None) -> None: """Set up postgresql_exporter options (port).""" - if postgres_snap is None: - cache = snap.SnapCache() - postgres_snap = cache[charm_refresh.snap_name()] - - postgres_snap.set({ + config = { "exporter.user": "monitoring", "exporter.password": self.state.get_secret(APP_SCOPE, MONITORING_PASSWORD_KEY), - }) + } + if snap_name is None: + snap_name = charm_refresh.snap_name() + snap.set(snap_name, {key: str(value) for key, value in config.items()}) - if postgres_snap.services[VM_METRICS_SERVICE_NAME]["active"] is False: - postgres_snap.start(services=[VM_METRICS_SERVICE_NAME], enable=True) + if service_states(snap_name)[VM_METRICS_SERVICE_NAME] is False: + snap.start(snap_name, services=[VM_METRICS_SERVICE_NAME], enable=True) else: - postgres_snap.restart(services=[VM_METRICS_SERVICE_NAME]) + snap.restart(snap_name, services=[VM_METRICS_SERVICE_NAME]) self.state.peer.data.update({"exporter-started": "True"}) - def _setup_pgbackrest_exporter(self, postgres_snap: snap.Snap | None = None) -> None: + def _setup_pgbackrest_exporter(self, snap_name: str | None = None) -> None: """Set up pgbackrest_exporter (port).""" - if postgres_snap is None: - cache = snap.SnapCache() - postgres_snap = cache[charm_refresh.snap_name()] - - if postgres_snap.services[VM_PGBACKREST_METRICS_SERVICE_NAME]["active"] is False: - postgres_snap.start(services=[VM_PGBACKREST_METRICS_SERVICE_NAME], enable=True) + if snap_name is None: + snap_name = charm_refresh.snap_name() + if service_states(snap_name)[VM_PGBACKREST_METRICS_SERVICE_NAME] is False: + snap.start( + snap_name, + services=[VM_PGBACKREST_METRICS_SERVICE_NAME], + enable=True, + ) else: - postgres_snap.restart(services=[VM_PGBACKREST_METRICS_SERVICE_NAME]) + snap.restart(snap_name, services=[VM_PGBACKREST_METRICS_SERVICE_NAME]) self.state.peer.data.update({"pgbackrest-exporter-started": "True"}) - def _setup_ldap_sync(self, postgres_snap: snap.Snap | None = None) -> None: + def _setup_ldap_sync(self, snap_name: str | None = None) -> None: """Set up postgresql_ldap_sync options (port).""" - if postgres_snap is None: - cache = snap.SnapCache() - postgres_snap = cache[charm_refresh.snap_name()] - ldap_params = self.ldap.get_ldap_parameters() ldap_url = urlparse(ldap_params["ldapurl"]) ldap_group_mappings = self.postgresql.build_postgresql_group_map( self.state.config.ldap_map ) - postgres_snap.set({ + config = { "ldap-sync.ldap_host": ldap_url.hostname, "ldap-sync.ldap_port": ldap_url.port, "ldap-sync.ldap_base_dn": ldap_params["ldapbasedn"], @@ -332,10 +329,13 @@ def _setup_ldap_sync(self, postgres_snap: snap.Snap | None = None) -> None: "ldap-sync.postgres_database": DATABASE_DEFAULT_NAME, "ldap-sync.postgres_username": USER, "ldap-sync.postgres_password": self._get_password, - }) + } + if snap_name is None: + snap_name = charm_refresh.snap_name() + snap.set(snap_name, {key: str(value) for key, value in config.items()}) logger.debug("Starting LDAP sync service") - postgres_snap.restart(services=["ldap-sync"]) + snap.restart(snap_name, services=["ldap-sync"]) def set_unit_status( self, @@ -455,9 +455,10 @@ def update_config( def post_refresh_side_effects(self) -> None: """Post-refresh workload side effects (port): exporters, pgbackrest, watcher.""" - self._setup_exporter() + snap_name = charm_refresh.snap_name() + self._setup_exporter(snap_name=snap_name) self.backup_manager.start_stop_pgbackrest_service() - self._setup_pgbackrest_exporter() + self._setup_pgbackrest_exporter(snap_name=snap_name) self.watcher_handler.update_unit_address() def has_async_replication_relation(self) -> bool: diff --git a/single_kernel_postgresql/events/postgresql.py b/single_kernel_postgresql/events/postgresql.py index b905bf29..162d01a7 100644 --- a/single_kernel_postgresql/events/postgresql.py +++ b/single_kernel_postgresql/events/postgresql.py @@ -1202,7 +1202,7 @@ def _on_storage_detaching(self, _) -> None: # Disable too, so a mid-teardown restart of the unit can't re-enable # the services and re-grab the storage mounts before Juju finishes # unmounting. - snap.SnapCache()[charm_refresh.snap_name()].stop(disable=True) + snap.stop(charm_refresh.snap_name(), disable=True) except Exception: logger.exception("Failed to stop charmed-postgresql snap services") @@ -1234,8 +1234,8 @@ def _on_remove(self, _) -> None: ) return try: - snap.SnapCache()[charm_refresh.snap_name()].ensure(snap.SnapState.Absent) - except (snap.SnapError, snap.SnapNotFoundError): + snap.remove(charm_refresh.snap_name()) + except snap.Error: # Don't fail the hook: an error here would block the removal of the unit. logger.exception("Failed to remove charmed-postgresql snap") diff --git a/single_kernel_postgresql/managers/patroni.py b/single_kernel_postgresql/managers/patroni.py index 4298e0cb..5def32a2 100644 --- a/single_kernel_postgresql/managers/patroni.py +++ b/single_kernel_postgresql/managers/patroni.py @@ -22,6 +22,9 @@ with suppress(ImportError): from charmlibs import snap from charmlibs.systemd import daemon_reload + + from single_kernel_postgresql.utils.snap import logs_by_identifier, service_states +import charm_refresh import psycopg2 import psycopg2.extras import requests @@ -597,11 +600,11 @@ def patroni_logs(self, num_lines: int | Literal["all"] = 10) -> str: """ try: logger.debug("Getting Patroni logs...") - cache = snap.SnapCache() - selected_snap = cache["charmed-postgresql"] - # Lib definition of num_lines only allows int - return selected_snap.logs(services=["patroni"], num_lines=num_lines) # pyright: ignore - except snap.SnapError as e: + limit = None if num_lines == "all" else num_lines + return logs_by_identifier( + "charmed-postgresql", "charmed-postgresql.patroni", limit=limit + ) + except snap.Error as e: error_message = "Failed to get logs from patroni snap service" logger.exception(error_message, exc_info=e) return "" @@ -634,12 +637,11 @@ def stop_patroni(self) -> bool: """ try: logger.debug("Stopping Patroni...") - cache = snap.SnapCache() - selected_snap = cache["charmed-postgresql"] - selected_snap.stop(services=["patroni"]) + snap_name = charm_refresh.snap_name() + snap.stop(snap_name, services=["patroni"]) self._invalidate_cluster_status_cache() - return not selected_snap.services["patroni"]["active"] - except snap.SnapError as e: + return service_states(snap_name).get("patroni") is False + except snap.Error as e: error_message = "Failed to stop patroni snap service" logger.exception(error_message, exc_info=e) return False @@ -796,12 +798,10 @@ def restart_patroni(self) -> bool: """ try: logger.debug("Restarting Patroni...") - cache = snap.SnapCache() - selected_snap = cache["charmed-postgresql"] - selected_snap.restart(services=["patroni"]) + snap.restart("charmed-postgresql", services=["patroni"]) self._invalidate_cluster_status_cache() - return selected_snap.services["patroni"]["active"] - except snap.SnapError as e: + return service_states("charmed-postgresql").get("patroni", False) + except snap.Error as e: error_message = "Failed to start patroni snap service" logger.exception(error_message, exc_info=e) return False diff --git a/single_kernel_postgresql/scripts/raft_observer.py b/single_kernel_postgresql/scripts/raft_observer.py index 7b023a08..8619ae1c 100644 --- a/single_kernel_postgresql/scripts/raft_observer.py +++ b/single_kernel_postgresql/scripts/raft_observer.py @@ -6,7 +6,6 @@ from os import environ from subprocess import run -from charmlibs.snap import SnapCache from pysyncobj.utility import TcpUtility from yaml import safe_load @@ -17,6 +16,7 @@ RAFT_PORT, SNAP_DATA, ) +from single_kernel_postgresql.utils.snap import service_states PATRONI_CONF_FILE_PATH = f"{BASE_SNAP_DIR}/{SNAP_DATA}/{PATRONI_CONF_PATH}/patroni.yaml" @@ -75,7 +75,7 @@ def check_raft_connection(password: str) -> None: def main() -> None: """Main watch and dispatch.""" - if not SnapCache()["charmed-postgresql"].services["patroni"]["active"]: + if not service_states("charmed-postgresql").get("patroni", False): print("Patroni is not running") return if not (password := get_raft_password()): diff --git a/single_kernel_postgresql/utils/snap.py b/single_kernel_postgresql/utils/snap.py new file mode 100644 index 00000000..5cc594f0 --- /dev/null +++ b/single_kernel_postgresql/utils/snap.py @@ -0,0 +1,104 @@ +# Copyright 2026 Canonical Ltd. +# See LICENSE file for licensing details. + +"""Snap service queries and identifier-filtered logs missing from charmlibs-snap.""" + +from __future__ import annotations + +import httpx +from charmlibs import snap +from tenacity import Retrying, retry_if_exception, wait_fixed + + +def service_states(snap_name: str) -> dict[str, bool]: # noqa: C901 + """Return declared services and their active states from snapd. + + A missing snap raises ``snap.NotInstalledError``; an installed snap without + services returns an empty mapping. Query failures raise public ``snap.Error`` + subclasses, never an empty result that could be mistaken for absence. + """ + with httpx.Client( + transport=httpx.HTTPTransport(uds="/run/snapd.socket"), timeout=120 + ) as client: + for attempt in Retrying( + # Match charmlibs-snap 2: a failure at exactly five seconds still retries. + stop=lambda state: (state.seconds_since_start or 0) > 5, + wait=wait_fixed(0.25), + retry=retry_if_exception( + lambda error: ( + isinstance(error, snap.ConnectionError) + and not isinstance(error, snap.SocketNotFoundError) + ) + ), + reraise=True, + ): + with attempt: + try: + response = client.get( + "http://localhost/v2/apps", + params={"names": snap_name, "select": "service"}, + ) + except httpx.TimeoutException as exc: + raise snap.TimeoutError(str(exc)) from exc + except httpx.TransportError as exc: + cause: BaseException | None = exc + while cause is not None: + if isinstance(cause, FileNotFoundError): + raise snap.SocketNotFoundError(str(exc)) from exc + cause = cause.__cause__ or cause.__context__ + raise snap.ConnectionError(str(exc)) from exc + try: + body = response.json() + if body["type"] == "error": + result = body["result"] + if not isinstance(result, dict): + raise ValueError("Expected an error object") + error = ( + snap.NotInstalledError if result.get("kind") == "snap-not-found" else snap.APIError + ) + raise error( + result["message"], + kind=result.get("kind", ""), + value=result.get("value"), + status_code=response.status_code, + status=body.get("status"), + ) + if ( + not response.is_success + or body["type"] != "sync" + or not isinstance(body["result"], list) + ): + raise ValueError("Expected a synchronous service list") + states = {} + for service in body["result"]: + name, active = service["name"], service.get("active", False) + if not isinstance(name, str) or not name or not isinstance(active, bool): + raise ValueError("Invalid service name or active state") + states[name] = active + return states + except (ValueError, KeyError, TypeError) as exc: + raise snap.BadResponseError( + "Invalid snapd service response", response=response.text + ) from exc + + +def _format_log(entry: snap.LogEntry) -> str: + """Match v1's local timestamp and line layout for persisted restore IDs.""" + timestamp = entry.timestamp.astimezone().isoformat(timespec="seconds") + if timestamp.endswith("+00:00"): + timestamp = timestamp[:-6] + "Z" + return f"{timestamp} {entry.sid}[{entry.pid}]: {entry.message}\n" + + +def logs_by_identifier(snap_name: str, identifier: str, *, limit: int | None = None) -> str: + """Filter all snap logs by exact SID, then apply the line limit. + + Entries retain chronological order and v1 formatting. Snap query errors + propagate to the caller. Negative limits raise ``snap.Error``, like v1's CLI. + """ + if limit is not None and limit < 0: + raise snap.Error("Log limit must be non-negative") + entries = [entry for entry in snap.logs(snap_name, limit=None) if entry.sid == identifier] + if limit is not None: + entries = entries[-limit:] if limit else [] + return "".join(_format_log(entry) for entry in entries) diff --git a/single_kernel_postgresql/workload/vm.py b/single_kernel_postgresql/workload/vm.py index a0759c05..a52960da 100644 --- a/single_kernel_postgresql/workload/vm.py +++ b/single_kernel_postgresql/workload/vm.py @@ -42,6 +42,7 @@ VM_PGBACKREST_SERVICE_NAME, VM_ROTATE_LOGS_LOG_FILE, ) +from single_kernel_postgresql.utils.snap import service_states from single_kernel_postgresql.workload.base import BackupConfig, BaseWorkload, CommandResult from single_kernel_postgresql.workload.paths.vm import VMPaths @@ -85,9 +86,9 @@ def _find_service_pid(service: str) -> int | None: return None -def _read_vitality_hint(system_snap: snap.Snap) -> str: +def _read_vitality_hint() -> str: """Read the hint without confusing a failed query with an absent setting.""" - config = system_snap.get(None, typed=True) + config = snap.get("system") if not isinstance(config, dict): raise ValueError("Snap system configuration must be an object") resilience = config.get("resilience", {}) @@ -110,22 +111,14 @@ def ensure_snap_oom_protection(snap_name: str) -> int: Existing processes keep their adjustment until their normal next startup. """ try: - # Only the name is used by get/set; the remaining metadata are placeholders. - system_snap = snap.Snap( - name="system", - state=snap.SnapState.Present, - channel="", - revision="", - confinement="", - ) - hint = _read_vitality_hint(system_snap) + hint = _read_vitality_hint() entries = hint.split(",") if hint else [] if snap_name not in entries: if len(entries) >= SNAP_VITALITY_MAX_SNAPS: raise ValueError("Snap vitality hint is full") updated_hint = f"{hint},{snap_name}" if hint else snap_name - system_snap.set({SNAP_VITALITY_HINT: updated_hint}) - verified_hint = _read_vitality_hint(system_snap) + snap.set("system", {SNAP_VITALITY_HINT: updated_hint}) + verified_hint = _read_vitality_hint() verified_entries = verified_hint.split(",") if verified_hint else [] if verified_entries[: len(entries)] != entries or snap_name not in verified_entries: raise ValueError("Snap vitality hint verification failed") @@ -134,7 +127,7 @@ def ensure_snap_oom_protection(snap_name: str) -> int: rank = len(entries) - entries[::-1].index(snap_name) return SNAP_OOM_SCORE_ADJUST_MIN + rank except (snap.Error, OSError, HTTPException, ValueError) as exc: - raise snap.SnapError(f"Failed to configure OOM protection for {snap_name}: {exc}") from exc + raise snap.Error(f"Failed to configure OOM protection for {snap_name}: {exc}") from exc class VMWorkload(BaseWorkload): @@ -161,11 +154,9 @@ def install(self) -> None: def create_snap_alias(self, alias_name: str) -> None: """Create alias for the snap binary.""" - cache = snap.SnapCache() - postgres_snap = cache[charm_refresh.snap_name()] try: - postgres_snap.alias(alias_name) - except snap.SnapError: + snap.alias(charm_refresh.snap_name(), alias_name, alias_name) + except snap.Error: logger.warning("Unable to create %s alias", alias_name) def install_snap_package( @@ -191,14 +182,18 @@ def install_snap_package( raise try: ensure_snap_oom_protection(charm_refresh.snap_name()) - snap_cache = snap.SnapCache() - snap_package = snap_cache[charm_refresh.snap_name()] - if not snap_package.present or refresh is not None: - snap_package.ensure(snap.SnapState.Present, revision=revision) + try: + snap.list_one(charm_refresh.snap_name()) + except snap.NotInstalledError: + present = False + else: + present = True + if not present or refresh is not None: + snap.ensure_installed(charm_refresh.snap_name(), revision=revision) if refresh is not None: refresh.update_snap_revision() - snap_package.hold() - except (snap.SnapError, snap.SnapNotFoundError) as e: + snap.hold(charm_refresh.snap_name()) + except snap.Error as e: logger.error( "An exception occurred when installing %s. Reason: %s", charm_refresh.snap_name(), @@ -214,11 +209,9 @@ def start_patroni(self) -> bool: """ try: logger.debug("Starting Patroni...") - cache = snap.SnapCache() - selected_snap = cache[POSTGRESQL_SNAP_NAME] - selected_snap.start(services=["patroni"]) - return selected_snap.services["patroni"]["active"] - except snap.SnapError as e: + snap.start(POSTGRESQL_SNAP_NAME, services=["patroni"]) + return service_states(POSTGRESQL_SNAP_NAME).get("patroni", False) + except snap.Error as e: error_message = "Failed to start patroni snap service" logger.exception(error_message, exc_info=e) return False @@ -226,10 +219,8 @@ def start_patroni(self) -> bool: def is_patroni_running(self) -> bool: """Check if the Patroni service is running.""" try: - cache = snap.SnapCache() - selected_snap = cache[POSTGRESQL_SNAP_NAME] - return selected_snap.services["patroni"]["active"] - except snap.SnapError as e: + return service_states(POSTGRESQL_SNAP_NAME).get("patroni", False) + except snap.NotInstalledError as e: logger.debug(f"Failed to check Patroni service: {e}") return False @@ -371,15 +362,15 @@ def stop(self) -> None: def start_service(self, service: str) -> None: """Start a named snap service.""" - snap.SnapCache()[POSTGRESQL_SNAP_NAME].start(services=[service]) + snap.start(POSTGRESQL_SNAP_NAME, services=[service]) def stop_service(self, service: str) -> None: """Stop a named snap service.""" - snap.SnapCache()[POSTGRESQL_SNAP_NAME].stop(services=[service]) + snap.stop(POSTGRESQL_SNAP_NAME, services=[service]) def restart_service(self, service: str) -> None: """Restart a named snap service.""" - snap.SnapCache()[POSTGRESQL_SNAP_NAME].restart(services=[service]) + snap.restart(POSTGRESQL_SNAP_NAME, services=[service]) def reload_service(self, service: str) -> None: """Reload a named snap service. @@ -402,8 +393,8 @@ def reload_service(self, service: str) -> None: def service_exists(self, service: str) -> bool: """Whether the snap declares the named service.""" try: - services = snap.SnapCache()[POSTGRESQL_SNAP_NAME].services - except snap.SnapError: + services = service_states(POSTGRESQL_SNAP_NAME) + except snap.NotInstalledError: return False return service in services @@ -414,10 +405,10 @@ def service_is_running(self, service: str) -> bool: mapping; that reads as not running. """ try: - services = snap.SnapCache()[POSTGRESQL_SNAP_NAME].services - except (snap.SnapError, snap.SnapNotFoundError): + services = service_states(POSTGRESQL_SNAP_NAME) + except snap.NotInstalledError: return False - return services.get(service, {}).get("active", False) + return services.get(service, False) def empty_data_files(self) -> bool: """Empty the PostgreSQL data directory in preparation of backup restore.""" @@ -611,10 +602,10 @@ def root(self) -> PathProtocol: def workload_present(self) -> bool: """Flag to check if workload is present and ready.""" # check if snap is installed as an indicator of workload presence - cache = snap.SnapCache() try: - return cache[charm_refresh.snap_name()].present - except snap.SnapError: + snap.list_one(charm_refresh.snap_name()) + return True + except snap.NotInstalledError: return False def get_available_memory(self) -> int: @@ -632,5 +623,4 @@ def get_available_resources(self) -> tuple[int, int]: def get_snap_revision(self) -> str: """Returns the installed workload snap revision.""" - cache = snap.SnapCache() - return cache[charm_refresh.snap_name()].revision + return snap.list_one(charm_refresh.snap_name()).revision diff --git a/tests/charms/postgresql_vm_test_charm/poetry.lock b/tests/charms/postgresql_vm_test_charm/poetry.lock index 7ba65c04..a2014ee7 100644 --- a/tests/charms/postgresql_vm_test_charm/poetry.lock +++ b/tests/charms/postgresql_vm_test_charm/poetry.lock @@ -292,19 +292,16 @@ ops = ">=2.19,<4" [[package]] name = "charmlibs-snap" -version = "1.0.1.post0" +version = "2.0.0" description = "The charmlibs.snap package." optional = false python-versions = ">=3.10" groups = ["main"] files = [ - {file = "charmlibs_snap-1.0.1.post0-py3-none-any.whl", hash = "sha256:655041096952c63e92c8d25a6183149f0594d4888be4be62a9635cb96897aa01"}, - {file = "charmlibs_snap-1.0.1.post0.tar.gz", hash = "sha256:1e8da752ee405aa981665da8c4772016236baf80d2d902b02ec8c1c640fb2844"}, + {file = "charmlibs_snap-2.0.0-py3-none-any.whl", hash = "sha256:6e479163ede22f9ab4b66adead2d4ce4cdc6eb77f36f88c50c4d3d3b075da040"}, + {file = "charmlibs_snap-2.0.0.tar.gz", hash = "sha256:82bc863919614436bf4e8e38cedaa4d809c3d4e1eedab10b2eeb97006116cd29"}, ] -[package.dependencies] -opentelemetry-api = "*" - [[package]] name = "charmlibs-systemd" version = "1.0.0.post0" @@ -2089,4 +2086,4 @@ h11 = ">=0.16.0,<1" [metadata] lock-version = "2.1" python-versions = "^3.12" -content-hash = "0be311de3dab9bf99eff9e2cf673004e9aab5531674c138480d9ef7cbb913562" +content-hash = "87e467e5b8762b2283e3b07cde92334eafe05f630346f4765e760f6a74258a77" diff --git a/tests/charms/postgresql_vm_test_charm/pyproject.toml b/tests/charms/postgresql_vm_test_charm/pyproject.toml index ee07d61b..e2279b65 100644 --- a/tests/charms/postgresql_vm_test_charm/pyproject.toml +++ b/tests/charms/postgresql_vm_test_charm/pyproject.toml @@ -18,7 +18,7 @@ jinja2 = "^3.1.6" pysyncobj = "^0.3.17" psutil = "^7.2.2" charm-refresh = "^3.1.0.2" -charmlibs-snap = "^1.0.1" +charmlibs-snap = "^2.0.0" charmlibs-systemd = "^1.0.0.post0" charmlibs-interfaces-tls-certificates = "^1.12.0" charmlibs-pathops = "^1.3.0" diff --git a/tests/unit/test_async_replication.py b/tests/unit/test_async_replication.py index 6cfdd941..e83cb672 100644 --- a/tests/unit/test_async_replication.py +++ b/tests/unit/test_async_replication.py @@ -548,7 +548,13 @@ def test_secret_changed_syncs_the_internal_secret(harness): # Emitted through the framework, so the observer registration is itself exercised. with ( patch.object(CharmState, "set_secret") as set_secret, - patch("single_kernel_postgresql.charms.vm_charm.snap.SnapCache"), + patch("single_kernel_postgresql.charms.vm_charm.snap.set"), + patch("single_kernel_postgresql.charms.vm_charm.snap.start"), + patch("single_kernel_postgresql.charms.vm_charm.snap.restart"), + patch( + "single_kernel_postgresql.charms.vm_charm.service_states", + return_value={"prometheus-postgres-exporter": False, "pgbackrest-exporter": False}, + ), ): harness.set_secret_content(secret_id, {"replication-password": "pw"}) diff --git a/tests/unit/test_observer.py b/tests/unit/test_observer.py index 6de3562a..8cb9edab 100644 --- a/tests/unit/test_observer.py +++ b/tests/unit/test_observer.py @@ -646,3 +646,37 @@ def test_authorisation_rules_main(substrate): _get.assert_any_call("http://server1:8008/cluster") _get.assert_any_call("http://server2:8008/cluster") assert _check_for_database_changes.called + + +@pytest.mark.parametrize( + "states,check", [({"patroni": True}, True), ({"patroni": False}, False), ({}, False)] +) +def test_raft_observer_gates_on_patroni_state(states, check): + from single_kernel_postgresql.scripts import raft_observer + + with ( + patch.object(raft_observer, "service_states", return_value=states), + patch.object(raft_observer, "get_raft_password", return_value="secret") as password, + patch.object(raft_observer, "check_raft_connection") as connection, + ): + raft_observer.main() + assert password.called is check + if check: + connection.assert_called_once_with("secret") + else: + connection.assert_not_called() + + +def test_raft_observer_query_failure_does_not_check_connection(): + from charmlibs import snap + from single_kernel_postgresql.scripts import raft_observer + + with ( + patch.object( + raft_observer, "service_states", side_effect=snap.ConnectionError("unavailable") + ), + patch.object(raft_observer, "check_raft_connection") as connection, + pytest.raises(snap.ConnectionError), + ): + raft_observer.main() + connection.assert_not_called() diff --git a/tests/unit/test_oom.py b/tests/unit/test_oom.py index b1dc60de..9c189f1f 100644 --- a/tests/unit/test_oom.py +++ b/tests/unit/test_oom.py @@ -3,7 +3,7 @@ import json from http.client import IncompleteRead -from unittest.mock import call, patch +from unittest.mock import Mock, call, patch import pytest import single_kernel_postgresql.workload.vm as oom @@ -16,24 +16,27 @@ def config(hint): @pytest.fixture def snap_factory(): - with patch("single_kernel_postgresql.workload.vm.snap.Snap", autospec=True) as factory: - yield factory + with ( + patch("single_kernel_postgresql.workload.vm.snap.get") as get, + patch("single_kernel_postgresql.workload.vm.snap.set") as set_config, + ): + calls = Mock() + calls.attach_mock(get, "get") + calls.attach_mock(set_config, "set") + yield calls @pytest.mark.parametrize("initial", [{}, {"resilience": {}}, config("")]) def test_missing_or_empty_hint(snap_factory, initial): - read = snap_factory.return_value.get + read = snap_factory.get read.side_effect = [initial, config("charmed-postgresql")] assert oom.ensure_snap_oom_protection("charmed-postgresql") == -899 - snap_factory.assert_called_once_with( - name="system", state=snap.SnapState.Present, channel="", revision="", confinement="" - ) - assert snap_factory.return_value.mock_calls == [ - call.get(None, typed=True), - call.set({"resilience.vitality-hint": "charmed-postgresql"}), - call.get(None, typed=True), + assert snap_factory.mock_calls == [ + call.get("system"), + call.set("system", {"resilience.vitality-hint": "charmed-postgresql"}), + call.get("system"), ] @@ -46,15 +49,15 @@ def test_missing_or_empty_hint(snap_factory, initial): ], ) def test_append_preserves_order_and_duplicates(snap_factory, hint, rank): - read, write = snap_factory.return_value.get, snap_factory.return_value.set + read, write = snap_factory.get, snap_factory.set updated = f"{hint},charmed-postgresql" read.side_effect = [config(hint), config(updated), config(updated)] assert oom.ensure_snap_oom_protection("charmed-postgresql") == -900 + rank assert oom.ensure_snap_oom_protection("charmed-postgresql") == -900 + rank - assert snap_factory.call_count == 2 - write.assert_called_once_with({"resilience.vitality-hint": updated}) + assert read.call_count == 3 + write.assert_called_once_with("system", {"resilience.vitality-hint": updated}) @pytest.mark.parametrize( @@ -68,22 +71,21 @@ def test_append_preserves_order_and_duplicates(snap_factory, hint, rank): ], ) def test_existing_hint_uses_last_rank_without_write(snap_factory, hint, rank): - read, write = snap_factory.return_value.get, snap_factory.return_value.set + read, write = snap_factory.get, snap_factory.set read.return_value = config(hint) assert oom.ensure_snap_oom_protection("charmed-postgresql") == -900 + rank assert oom.ensure_snap_oom_protection("charmed-postgresql") == -900 + rank - assert snap_factory.call_count == 2 - assert read.call_args_list == [call(None, typed=True)] * 2 + assert read.call_args_list == [call("system")] * 2 write.assert_not_called() def test_full_hint_does_not_write(snap_factory): - read, write = snap_factory.return_value.get, snap_factory.return_value.set + read, write = snap_factory.get, snap_factory.set read.return_value = config(",".join(f"snap-{i}" for i in range(100))) - with pytest.raises(snap.SnapError, match="full"): + with pytest.raises(snap.Error, match="full"): oom.ensure_snap_oom_protection("charmed-postgresql") write.assert_not_called() @@ -106,10 +108,10 @@ def test_full_hint_does_not_write(snap_factory): ], ) def test_invalid_configuration_does_not_write(snap_factory, value): - read, write = snap_factory.return_value.get, snap_factory.return_value.set + read, write = snap_factory.get, snap_factory.set read.return_value = value - with pytest.raises(snap.SnapError): + with pytest.raises(snap.Error): oom.ensure_snap_oom_protection("charmed-postgresql") write.assert_not_called() @@ -119,16 +121,16 @@ def test_invalid_configuration_does_not_write(snap_factory, value): "error", [ OSError("snap missing"), - snap.SnapError("snap get failed"), - snap.SnapAPIError({}, 500, "Internal Server Error", "snapd unavailable"), + snap.Error("snap get failed"), + snap.APIError("snapd unavailable", kind="", value=None, status_code=500), json.JSONDecodeError("invalid system configuration", "", 0), ], ) def test_read_failure_does_not_write(snap_factory, error): - read, write = snap_factory.return_value.get, snap_factory.return_value.set + read, write = snap_factory.get, snap_factory.set read.side_effect = error - with pytest.raises(snap.SnapError) as exc: + with pytest.raises(snap.Error) as exc: oom.ensure_snap_oom_protection("charmed-postgresql") assert exc.value.__cause__ is error @@ -140,17 +142,17 @@ def test_read_failure_does_not_write(snap_factory, error): [ OSError("snap socket unavailable"), IncompleteRead(b"truncated snapd response"), - snap.SnapError("configuration change failed"), - snap.SnapAPIError({}, 500, "Internal Server Error", "snapd unavailable"), + snap.Error("configuration change failed"), + snap.APIError("snapd unavailable", kind="", value=None, status_code=500), TimeoutError("configuration change timed out"), ], ) def test_write_failure_does_not_retry(snap_factory, error): - read, write = snap_factory.return_value.get, snap_factory.return_value.set + read, write = snap_factory.get, snap_factory.set read.return_value = config("postgresql") write.side_effect = error - with pytest.raises(snap.SnapError) as exc: + with pytest.raises(snap.Error) as exc: oom.ensure_snap_oom_protection("charmed-postgresql") assert exc.value.__cause__ is error @@ -169,25 +171,25 @@ def test_write_failure_does_not_retry(snap_factory, error): config(None), "bad-json", json.JSONDecodeError("invalid system configuration", "", 0), - snap.SnapError("verification read failed"), - snap.SnapAPIError({}, 500, "Internal Server Error", "snapd unavailable"), + snap.Error("verification read failed"), + snap.APIError("snapd unavailable", kind="", value=None, status_code=500), ], ) def test_verification_failure_does_not_overwrite_again(snap_factory, verified): - read, write = snap_factory.return_value.get, snap_factory.return_value.set + read, write = snap_factory.get, snap_factory.set read.side_effect = [config("postgresql,other,postgresql"), verified] - with pytest.raises(snap.SnapError): + with pytest.raises(snap.Error): oom.ensure_snap_oom_protection("charmed-postgresql") assert read.call_count == 2 - write.assert_called_once_with({ - "resilience.vitality-hint": "postgresql,other,postgresql,charmed-postgresql" - }) + write.assert_called_once_with( + "system", {"resilience.vitality-hint": "postgresql,other,postgresql,charmed-postgresql"} + ) def test_rank_comes_from_verified_configuration(snap_factory): - read = snap_factory.return_value.get + read = snap_factory.get read.side_effect = [ config("postgresql"), config("postgresql,charmed-postgresql,other,charmed-postgresql"), diff --git a/tests/unit/test_patroni_manager.py b/tests/unit/test_patroni_manager.py index dcbc23f5..687f21f3 100644 --- a/tests/unit/test_patroni_manager.py +++ b/tests/unit/test_patroni_manager.py @@ -352,41 +352,58 @@ def test_start_patroni(substrate, patroni): pytest.skip("VM only") return - with patch("single_kernel_postgresql.managers.patroni.snap.SnapCache") as _snap_cache: - _cache = _snap_cache.return_value - _selected_snap = _cache.__getitem__.return_value - _selected_snap.start.side_effect = [None, snap.SnapError] - - # Test a success scenario. + with ( + patch( + "single_kernel_postgresql.workload.vm.snap.start", + side_effect=[None, snap.Error("failed")], + ) as start, + patch( + "single_kernel_postgresql.workload.vm.service_states", return_value={"patroni": True} + ), + ): assert patroni.start_patroni() - _cache.__getitem__.assert_called_once_with("charmed-postgresql") - _selected_snap.start.assert_called_once_with(services=[PATRONI_SERVICE]) - - # Test a fail scenario. + start.assert_called_once_with("charmed-postgresql", services=[PATRONI_SERVICE]) assert not patroni.start_patroni() -def test_stop_patroni(substrate, patroni): +@pytest.mark.parametrize( + "states,expected", [({"patroni": False}, True), ({"patroni": True}, False), ({}, False)] +) +def test_stop_patroni(substrate, patroni, states, expected): if substrate == Substrates.K8S: pytest.skip("VM only") - return + with ( + patch( + "single_kernel_postgresql.managers.patroni.charm_refresh.snap_name", + return_value="custom-postgresql", + ) as snap_name, + patch("single_kernel_postgresql.managers.patroni.snap.stop") as stop, + patch( + "single_kernel_postgresql.managers.patroni.service_states", return_value=states + ) as query, + ): + assert patroni.stop_patroni() is expected + stop.assert_called_once_with("custom-postgresql", services=[PATRONI_SERVICE]) + query.assert_called_once_with("custom-postgresql") + snap_name.assert_called_once_with() - with patch("single_kernel_postgresql.managers.patroni.snap.SnapCache") as _snap_cache: - _cache = _snap_cache.return_value - _selected_snap = _cache.__getitem__.return_value - _selected_snap.stop.side_effect = [None, snap.SnapError] - _selected_snap.services.__getitem__.return_value.__getitem__.return_value = False - - # Test a success scenario. - assert patroni.stop_patroni() - _cache.__getitem__.assert_called_once_with("charmed-postgresql") - _selected_snap.stop.assert_called_once_with(services=[PATRONI_SERVICE]) - _selected_snap.services.__getitem__.return_value.__getitem__.assert_called_once_with( - "active" - ) - # Test a fail scenario. +def test_stop_patroni_handles_errors(substrate, patroni): + if substrate == Substrates.K8S: + pytest.skip("VM only") + with ( + patch( + "single_kernel_postgresql.managers.patroni.snap.stop", + side_effect=snap.Error("failed"), + ) as stop, + patch("single_kernel_postgresql.managers.patroni.service_states") as query, + ): + assert not patroni.stop_patroni() + query.assert_not_called() + stop.side_effect = None + query.side_effect = snap.ConnectionError("failed query") assert not patroni.stop_patroni() + query.assert_called_once_with("charmed-postgresql") def test_switchover(patroni): @@ -843,14 +860,18 @@ def test_patroni_logs(substrate, patroni): pytest.skip("VM only") return - with patch("single_kernel_postgresql.managers.patroni.snap.SnapCache") as _snap_cache: - # Test when the logs are returned successfully. - logs = _snap_cache.return_value.__getitem__.return_value.logs - logs.return_value = "fake-logs" + with patch( + "single_kernel_postgresql.managers.patroni.logs_by_identifier", return_value="fake-logs" + ) as logs: assert patroni.patroni_logs() == "fake-logs" - - # Test the charm fails to get the logs. - logs.side_effect = snap.SnapError + assert patroni.patroni_logs("all") == "fake-logs" + assert patroni.patroni_logs(2) == "fake-logs" + assert logs.call_args_list == [ + call("charmed-postgresql", "charmed-postgresql.patroni", limit=10), + call("charmed-postgresql", "charmed-postgresql.patroni", limit=None), + call("charmed-postgresql", "charmed-postgresql.patroni", limit=2), + ] + logs.side_effect = snap.Error("failed") assert patroni.patroni_logs() == "" @@ -1426,11 +1447,13 @@ def test_cluster_status_mutations_invalidate_the_cache(patroni): assert patroni.get_primary() == "postgresql-0" assert _parallel.call_count == 1 - with patch("single_kernel_postgresql.managers.patroni.snap.SnapCache") as _snap_cache: - _snap_cache.return_value.__getitem__.return_value.restart.return_value = None - _snap_cache.return_value.__getitem__.return_value.services = { - "patroni": {"active": True} - } + with ( + patch("single_kernel_postgresql.managers.patroni.snap.restart"), + patch( + "single_kernel_postgresql.managers.patroni.service_states", + return_value={"patroni": True}, + ), + ): assert patroni.restart_patroni() is True assert patroni.get_primary() == "postgresql-0" diff --git a/tests/unit/test_restore_manager.py b/tests/unit/test_restore_manager.py index 30dba321..cda74dd7 100755 --- a/tests/unit/test_restore_manager.py +++ b/tests/unit/test_restore_manager.py @@ -6,10 +6,13 @@ """Tests for the RestoreManager (restore checks, PITR helpers and orchestration).""" import logging +import time +from datetime import datetime from functools import partial -from unittest.mock import MagicMock +from unittest.mock import MagicMock, patch import pytest +from charmlibs import snap from data_platform_helpers.advanced_statuses import StatusObject from lightkube.core.exceptions import ApiError from lightkube.models.meta_v1 import Status @@ -23,6 +26,7 @@ from single_kernel_postgresql.config.statuses import GeneralStatuses from single_kernel_postgresql.core.peer_relation import PostgreSQLApplication from single_kernel_postgresql.managers.restore import PITR_FAILED_KEY, RestoreManager +from single_kernel_postgresql.utils import snap as snap_utils from single_kernel_postgresql.utils.backup import ( ANOTHER_CLUSTER_REPOSITORY_ERROR_MESSAGE, CANNOT_RESTORE_PITR, @@ -421,20 +425,43 @@ def test_restore_finalization_swallows_second_replan_failure(restore_manager, su # -- PITR helpers --------------------------------------------------------------------- -def test_is_pitr_failed_tracks_new_failures(restore_manager, substrate): +def test_is_pitr_failed_tracks_new_failures(restore_manager, substrate, monkeypatch): if substrate != "vm": pytest.skip("VM-only patroni logs") - restore_manager.patroni_manager.patroni_logs.return_value = ( - "2024-01-01T00:00:00.000Z localhost patroni.exceptions.PatroniFatalException:" - " Failed to bootstrap cluster" - ) - assert restore_manager.is_pitr_failed() == (True, True) - assert restore_manager.is_pitr_failed() == (True, False) - restore_manager.patroni_manager.patroni_logs.return_value = ( - "2024-01-02T00:00:00.000Z localhost patroni.exceptions.PatroniFatalException:" - " Failed to bootstrap cluster" - ) - assert restore_manager.is_pitr_failed() == (True, True) + try: + with monkeypatch.context() as local: + local.setenv("TZ", "UTC") + time.tzset() + expected = ( + "2026-10-26T13:41:19Z charmed-postgresql.patroni[53233]: " + "patroni.exceptions.PatroniFatalException: Failed to bootstrap cluster\n" + ) + restore_manager.patroni_manager.patroni_logs.return_value = expected + assert restore_manager.is_pitr_failed() == (True, True) + log = snap.LogEntry( + datetime.fromisoformat("2026-10-26T13:41:19.340706+00:00"), + "charmed-postgresql.patroni", + 53233, + "patroni.exceptions.PatroniFatalException: Failed to bootstrap cluster", + ) + with patch.object(snap, "logs", return_value=[log]): + formatted = snap_utils.logs_by_identifier( + "charmed-postgresql", "charmed-postgresql.patroni" + ) + restore_manager.patroni_manager.patroni_logs.return_value = formatted + assert restore_manager.is_pitr_failed() == (True, False) + assert restore_manager.state.peer.data["last_pitr_fail_id"] == "2026-10-26T13:41:19Z" + later = snap.LogEntry(log.timestamp.replace(minute=42), log.sid, log.pid, log.message) + with patch.object(snap, "logs", return_value=[log, later]): + restore_manager.patroni_manager.patroni_logs.return_value = ( + snap_utils.logs_by_identifier( + "charmed-postgresql", "charmed-postgresql.patroni" + ) + ) + assert restore_manager.is_pitr_failed() == (True, True) + assert restore_manager.state.peer.data["last_pitr_fail_id"] == "2026-10-26T13:42:19Z" + finally: + time.tzset() def test_is_pitr_failed_reports_no_failure(restore_manager, substrate): diff --git a/tests/unit/test_utils_snap.py b/tests/unit/test_utils_snap.py new file mode 100644 index 00000000..47d7d2e7 --- /dev/null +++ b/tests/unit/test_utils_snap.py @@ -0,0 +1,236 @@ +# Copyright 2026 Canonical Ltd. +# See LICENSE file for licensing details. + +import time +from datetime import UTC, datetime +from unittest.mock import Mock, patch + +import httpx +import pytest +from charmlibs import snap +from single_kernel_postgresql.utils import snap as snap_utils + + +@pytest.fixture +def snapd(): + def respond(body, status=200): + requests = [] + + def handle(request): + requests.append(request) + assert len(requests) == 1, "Received responses must not be retried" + assert request.extensions["timeout"] == dict.fromkeys( + ("connect", "read", "write", "pool"), 120 + ) + assert request.url.path == "/v2/apps" + assert dict(request.url.params) == {"names": "charmed-postgresql", "select": "service"} + return httpx.Response(status, json=body) + + return patch.object( + snap_utils.httpx, "HTTPTransport", return_value=httpx.MockTransport(handle) + ) + + return respond + + +def test_service_states_distinguish_declared_stopped_and_missing(snapd): + with snapd({ + "type": "sync", + "status-code": 200, + "result": [ + {"snap": "charmed-postgresql", "name": "patroni", "active": True}, + {"snap": "charmed-postgresql", "name": "ldap-sync", "active": False}, + {"snap": "charmed-postgresql", "name": "exporter"}, + ], + }): + assert snap_utils.service_states("charmed-postgresql") == { + "patroni": True, + "ldap-sync": False, + "exporter": False, + } + with snapd({"type": "sync", "status-code": 200, "result": []}): + assert snap_utils.service_states("charmed-postgresql") == {} + + +@pytest.mark.parametrize( + "kind,status,error", + [ + ("snap-not-found", 404, snap.NotInstalledError), + ("", 500, snap.APIError), + ], +) +def test_service_states_api_errors(snapd, kind, status, error): + with ( + snapd( + { + "type": "error", + "status-code": status, + "status": "Failure", + "result": { + "message": "query failed", + "kind": kind, + "value": "charmed-postgresql", + }, + }, + status, + ), + pytest.raises(error, match="query failed"), + ): + snap_utils.service_states("charmed-postgresql") + + +@pytest.mark.parametrize( + "body", + [ + {"type": "sync", "result": None}, + {"type": "sync", "result": [None]}, + {"type": "sync", "result": [{}]}, + {"type": "sync", "result": [{"name": "patroni", "active": "false"}]}, + {"type": "error", "result": []}, + ], +) +def test_service_states_malformed_response_is_not_absence(snapd, body): + with snapd(body), pytest.raises(snap.BadResponseError): + snap_utils.service_states("charmed-postgresql") + + +@pytest.fixture +def retry_clock(monkeypatch): + now = 0 + + def sleep(seconds): + nonlocal now + now += seconds + + sleeper = Mock(side_effect=sleep) + monkeypatch.setattr(time, "monotonic", lambda: now) + monkeypatch.setattr(time, "sleep", sleeper) + return sleeper + + +def test_service_states_retries_transient_connection_failure(retry_clock): + handle = Mock( + side_effect=[ + httpx.ConnectError("restarting"), + httpx.Response( + 200, json={"type": "sync", "result": [{"name": "patroni", "active": True}]} + ), + ] + ) + with patch.object(snap_utils.httpx, "HTTPTransport", return_value=httpx.MockTransport(handle)): + assert snap_utils.service_states("charmed-postgresql") == {"patroni": True} + assert handle.call_count == 2 + retry_clock.assert_called_once_with(0.25) + + +def test_service_states_connection_retry_budget(retry_clock): + error = httpx.ConnectError("unavailable") + handle = Mock(side_effect=error) + with ( + patch.object(snap_utils.httpx, "HTTPTransport", return_value=httpx.MockTransport(handle)), + pytest.raises(snap.ConnectionError) as caught, + ): + snap_utils.service_states("charmed-postgresql") + assert caught.value.__cause__ is error + assert handle.call_count == 22 + assert retry_clock.call_count == 21 + assert all(call.args == (0.25,) for call in retry_clock.call_args_list) + assert time.monotonic() == 5.25 + + +@pytest.mark.parametrize("error_type", [httpx.ReadTimeout, httpx.ConnectTimeout]) +def test_service_states_timeouts_are_not_retried(error_type, retry_clock): + error = error_type("slow") + handle = Mock(side_effect=error) + with ( + patch.object(snap_utils.httpx, "HTTPTransport", return_value=httpx.MockTransport(handle)), + pytest.raises(snap.TimeoutError) as caught, + ): + snap_utils.service_states("charmed-postgresql") + assert caught.value.__cause__ is error + handle.assert_called_once() + retry_clock.assert_not_called() + + +def test_service_states_missing_socket_is_not_retried(tmp_path, retry_clock): + # Preserve HTTPX's real cause/context chain, including its suppressed OS error. + with ( + httpx.Client( + transport=httpx.HTTPTransport(uds=str(tmp_path / "missing.socket")) + ) as client, + pytest.raises(httpx.ConnectError) as transport_error, + ): + client.get("http://localhost/v2/apps") + handle = Mock(side_effect=transport_error.value) + with ( + patch.object(snap_utils.httpx, "HTTPTransport", return_value=httpx.MockTransport(handle)), + pytest.raises(snap.SocketNotFoundError) as caught, + ): + snap_utils.service_states("charmed-postgresql") + assert caught.value.__cause__ is transport_error.value + handle.assert_called_once() + retry_clock.assert_not_called() + + +@pytest.fixture +def local_timezone(monkeypatch): + def use(zone): + monkeypatch.setenv("TZ", zone) + time.tzset() + + yield use + monkeypatch.undo() + time.tzset() + + +@pytest.mark.parametrize("limit,expected", [(None, [0, 1, 2]), (2, [1, 2]), (0, [])]) +def test_logs_filter_exact_sid_before_tailing(limit, expected, local_timezone): + local_timezone("UTC") + entries = [ + snap.LogEntry( + datetime(2026, 10, 26, 13, 41, i, 123456, UTC), + "charmed-postgresql.patroni", + 42, + str(i), + ) + for i in range(3) + ] + entries.insert( + 1, snap.LogEntry(datetime.now(UTC), "charmed-postgresql.patroni-other", 7, "other") + ) + entries.append(snap.LogEntry(datetime.now(UTC), "charmed-postgresql.exporter", 7, "other")) + with patch.object(snap, "logs", return_value=entries) as logs: + assert snap_utils.logs_by_identifier( + "charmed-postgresql", "charmed-postgresql.patroni", limit=limit + ) == "".join( + f"2026-10-26T13:41:0{i}Z charmed-postgresql.patroni[42]: {i}\n" for i in expected + ) + logs.assert_called_once_with("charmed-postgresql", limit=None) + + +def test_logs_format_local_time_and_preserve_message_newlines(local_timezone): + local_timezone("EST5") + entry = snap.LogEntry( + datetime(2026, 10, 26, 13, 41, 19, 340706, UTC), "service", 42, "one\ntwo" + ) + with patch.object(snap, "logs", return_value=[entry]): + assert ( + snap_utils.logs_by_identifier("example", "service") + == "2026-10-26T08:41:19-05:00 service[42]: one\ntwo\n" + ) + + +def test_logs_empty_and_failure(): + with patch.object(snap, "logs", return_value=[]): + assert snap_utils.logs_by_identifier("example", "service") == "" + with ( + patch.object(snap, "logs", side_effect=snap.ConnectionError("unavailable")), + pytest.raises(snap.ConnectionError), + ): + snap_utils.logs_by_identifier("example", "service") + + +def test_negative_log_limit_is_rejected(): + with patch.object(snap, "logs") as logs, pytest.raises(snap.Error): + snap_utils.logs_by_identifier("example", "service", limit=-1) + logs.assert_not_called() diff --git a/tests/unit/test_vm_charm.py b/tests/unit/test_vm_charm.py index 3fb66e0f..d3a8e5ef 100644 --- a/tests/unit/test_vm_charm.py +++ b/tests/unit/test_vm_charm.py @@ -583,3 +583,77 @@ def test_pitr_failure_persists_blocked_through_collect(charm, harness): ): harness.evaluate_status() assert charm.unit.status == BlockedStatus(CANNOT_RESTORE_PITR) + + +@pytest.mark.parametrize("active", [True, False]) +@pytest.mark.parametrize( + "service,method", + [ + ("prometheus-postgres-exporter", "_setup_exporter"), + ("pgbackrest-exporter", "_setup_pgbackrest_exporter"), + ], +) +def test_exporters_start_enabled_or_restart(charm, active, service, method): + with ( + patch( + "single_kernel_postgresql.charms.vm_charm.service_states", + return_value={service: active}, + ), + patch("single_kernel_postgresql.charms.vm_charm.snap.set") as set_config, + patch("single_kernel_postgresql.charms.vm_charm.snap.start") as start, + patch("single_kernel_postgresql.charms.vm_charm.snap.restart") as restart, + patch.object(charm.state, "get_secret", return_value=None), + ): + getattr(charm, method)() + if active: + restart.assert_called_once_with("charmed-postgresql", services=[service]) + start.assert_not_called() + else: + start.assert_called_once_with("charmed-postgresql", services=[service], enable=True) + restart.assert_not_called() + if method == "_setup_exporter": + set_config.assert_called_once_with( + "charmed-postgresql", {"exporter.user": "monitoring", "exporter.password": "None"} + ) + + +def test_metrics_password_uses_scalar_read(charm): + with ( + patch( + "single_kernel_postgresql.charms.vm_charm.snap.get_one", return_value="current" + ) as get_one, + patch.object(charm.state, "get_secret", return_value="current"), + patch.object(charm, "_setup_exporter") as setup, + ): + charm._restart_metrics_service(snap_name="charmed-postgresql") + get_one.assert_called_once_with("charmed-postgresql", "exporter.password") + setup.assert_not_called() + + +def test_ldap_config_preserves_string_values(charm): + charm.ldap = Mock() + charm.ldap.get_ldap_parameters.return_value = { + "ldapurl": "ldap://ldap.example:389", + "ldapbasedn": "dc=example", + "ldapbinddn": "cn=reader", + "ldapbindpasswd": "secret", + } + with ( + patch.object( + type(charm), + "postgresql", + new_callable=PropertyMock, + return_value=Mock(build_postgresql_group_map=Mock(return_value={})), + ), + patch.object(type(charm), "_get_password", new_callable=PropertyMock, return_value=None), + patch("single_kernel_postgresql.charms.vm_charm.snap.set") as set_config, + patch("single_kernel_postgresql.charms.vm_charm.snap.restart") as restart, + ): + charm._setup_ldap_sync() + name, config = set_config.call_args.args + assert name == "charmed-postgresql" + assert config["ldap-sync.ldap_port"] == "389" + assert config["ldap-sync.postgres_port"] == "5432" + assert config["ldap-sync.postgres_password"] == "None" + assert all(isinstance(value, str) for value in config.values()) + restart.assert_called_once_with("charmed-postgresql", services=["ldap-sync"]) diff --git a/tests/unit/test_vm_lifecycle_events.py b/tests/unit/test_vm_lifecycle_events.py index ca353a89..28eb4e6d 100644 --- a/tests/unit/test_vm_lifecycle_events.py +++ b/tests/unit/test_vm_lifecycle_events.py @@ -10,9 +10,11 @@ from unittest.mock import Mock, PropertyMock, patch import pytest +from charmlibs import snap from ops import BlockedStatus, ModelError from single_kernel_postgresql.config.enums import Substrates from single_kernel_postgresql.config.literals import PEER_RELATION +from single_kernel_postgresql.managers.patroni import PatroniManager from single_kernel_postgresql.utils.backup import ( FAILED_TO_CHECK_STANZA_ERROR_MESSAGE, S3_BLOCK_MESSAGES, @@ -137,13 +139,17 @@ def test_storage_detaching_noop_on_scale_down(handler, harness): def test_storage_detaching_stops_on_teardown(handler, harness): - with patch.object( - type(handler.state.application), - "planned_units", - new_callable=PropertyMock, - return_value=0, + with ( + patch.object( + type(handler.state.application), + "planned_units", + new_callable=PropertyMock, + return_value=0, + ), + patch("single_kernel_postgresql.events.postgresql.snap.stop") as stop, ): handler._on_storage_detaching(Mock()) + stop.assert_called_once_with("charmed-postgresql", disable=True) handler.observer_manager.stop_observer.assert_called_once() handler.backup_manager.stop_log_rotation.assert_called_once() @@ -151,3 +157,30 @@ def test_storage_detaching_stops_on_teardown(handler, harness): def test_check_stanza_message_is_an_s3_block_message(): """The check-stanza failure message is appended to S3_BLOCK_MESSAGES (lock).""" assert FAILED_TO_CHECK_STANZA_ERROR_MESSAGE in S3_BLOCK_MESSAGES + + +def test_process_recovery_propagates_running_probe_failure(request): + member_inactive = PatroniManager.member_inactive + handler = request.getfixturevalue("handler") + error = snap.TimeoutError("snapd query timed out") + with ( + patch.object(PatroniManager, "member_inactive", member_inactive), + patch.object( + type(handler.membership_manager.state.application), + "members_ips", + new_callable=PropertyMock, + return_value={handler.state.unit_ip}, + ), + patch("single_kernel_postgresql.workload.vm.service_states", side_effect=error) as query, + patch("single_kernel_postgresql.events.postgresql.os.listdir") as listdir, + patch("single_kernel_postgresql.events.postgresql.os.rename") as rename, + patch.object(handler.patroni_manager, "restart_patroni") as restart, + pytest.raises(snap.TimeoutError) as caught, + ): + handler._handle_processes_failures() + assert caught.value is error + query.assert_called_once_with("charmed-postgresql") + listdir.assert_not_called() + rename.assert_not_called() + restart.assert_not_called() + handler.observer_manager.start_observer.assert_not_called() diff --git a/tests/unit/test_workload.py b/tests/unit/test_workload.py index 29038244..c2577e61 100644 --- a/tests/unit/test_workload.py +++ b/tests/unit/test_workload.py @@ -153,81 +153,84 @@ def refresh_versions_dir(tmp_path, monkeypatch): def test_install_snap_package(refresh_versions_dir): workload = VMWorkload(".") with ( - patch("single_kernel_postgresql.workload.vm.snap.SnapCache") as _snap_cache, + patch( + "single_kernel_postgresql.workload.vm.snap.list_one", + side_effect=snap.NotInstalledError( + "missing", kind="snap-not-found", value="charmed-postgresql" + ), + ) as installed, + patch("single_kernel_postgresql.workload.vm.snap.ensure_installed") as ensure, + patch("single_kernel_postgresql.workload.vm.snap.hold") as hold, patch("single_kernel_postgresql.workload.vm.ensure_snap_oom_protection"), ): - _snap_package = _snap_cache.return_value.__getitem__.return_value - _snap_package.present = False - _revision = "416" - - # Test for problem with snap update. - _snap_package.ensure.side_effect = snap.SnapError("update failed") - with pytest.raises(snap.SnapError): + ensure.side_effect = snap.Error("update failed") + with pytest.raises(snap.Error): workload.install_snap_package(revision=None) - _snap_cache.return_value.__getitem__.assert_called_once_with("charmed-postgresql") - _snap_cache.assert_called_once_with() - _snap_package.ensure.assert_called_once_with(snap.SnapState.Present, revision=_revision) - - # Test for problem with snap missing. - _snap_cache.reset_mock() - _snap_package.reset_mock() - _snap_package.ensure.side_effect = snap.SnapNotFoundError - with pytest.raises(snap.SnapNotFoundError): + hold.assert_not_called() + installed.assert_called_once_with("charmed-postgresql") + ensure.assert_called_once_with("charmed-postgresql", revision="416") + + installed.reset_mock() + ensure.reset_mock() + ensure.side_effect = snap.NotInstalledError( + "missing", kind="snap-not-found", value="charmed-postgresql" + ) + with pytest.raises(snap.NotInstalledError): workload.install_snap_package(revision=None) - _snap_cache.return_value.__getitem__.assert_called_once_with("charmed-postgresql") - _snap_cache.assert_called_once_with() - _snap_package.ensure.assert_called_once_with(snap.SnapState.Present, revision=_revision) - - # Test for correct install. - _snap_cache.reset_mock() - _snap_package.reset_mock() - _snap_package.ensure.side_effect = None + installed.assert_called_once_with("charmed-postgresql") + ensure.assert_called_once_with("charmed-postgresql", revision="416") + + installed.reset_mock() + ensure.reset_mock() + ensure.side_effect = None workload.install_snap_package(revision=None) - _snap_cache.assert_called_once_with() - _snap_cache.return_value.__getitem__.assert_called_once_with("charmed-postgresql") - _snap_package.ensure.assert_called_once_with(snap.SnapState.Present, revision=_revision) - _snap_package.hold.assert_called_once_with() - - # Test with revision - _snap_cache.reset_mock() - _snap_package.reset_mock() + installed.assert_called_once_with("charmed-postgresql") + ensure.assert_called_once_with("charmed-postgresql", revision="416") + hold.assert_called_once_with("charmed-postgresql") + + installed.reset_mock() + ensure.reset_mock() + hold.reset_mock() workload.install_snap_package(revision="42") - _snap_cache.assert_called_once_with() - _snap_cache.return_value.__getitem__.assert_called_once_with("charmed-postgresql") - _snap_package.ensure.assert_called_once_with(snap.SnapState.Present, revision="42") - _snap_package.hold.assert_called_once_with() - - # Test with refresh - _snap_cache.reset_mock() - _snap_package.reset_mock() - _snap_package.present = True - _refresh = Mock() - workload.install_snap_package(revision="42", refresh=_refresh) - _snap_cache.assert_called_once_with() - _snap_cache.return_value.__getitem__.assert_called_once_with("charmed-postgresql") - _snap_package.ensure.assert_called_once_with(snap.SnapState.Present, revision="42") - _refresh.update_snap_revision.assert_called_once_with() - _snap_package.hold.assert_called_once_with() - - # Test without refresh - _snap_cache.reset_mock() - _snap_package.reset_mock() + installed.assert_called_once_with("charmed-postgresql") + ensure.assert_called_once_with("charmed-postgresql", revision="42") + hold.assert_called_once_with("charmed-postgresql") + + installed.reset_mock() + ensure.reset_mock() + hold.reset_mock() + installed.side_effect = None + refresh = Mock() + workload.install_snap_package(revision="42", refresh=refresh) + installed.assert_called_once_with("charmed-postgresql") + ensure.assert_called_once_with("charmed-postgresql", revision="42") + refresh.update_snap_revision.assert_called_once_with() + hold.assert_called_once_with("charmed-postgresql") + + installed.reset_mock() + ensure.reset_mock() + hold.reset_mock() workload.install_snap_package(revision="42") - _snap_cache.assert_called_once_with() - _snap_cache.return_value.__getitem__.assert_called_once_with("charmed-postgresql") - _snap_package.ensure.assert_not_called() - _snap_package.hold.assert_not_called() - _refresh.update_snap_revision.assert_called_once_with() - - # Test with invalid machine architecture - _snap_cache.reset_mock() - _snap_package.reset_mock() - with patch("platform.machine") as _machine: - _machine.return_value = "missingarch" - with pytest.raises(KeyError): - workload.install_snap_package(revision=None) - assert not _snap_package.ensure.called - assert not _snap_package.hold.called + installed.assert_called_once_with("charmed-postgresql") + ensure.assert_not_called() + hold.assert_not_called() + refresh.update_snap_revision.assert_called_once_with() + + installed.reset_mock() + ensure.reset_mock() + hold.reset_mock() + installed.side_effect = snap.ConnectionError("unavailable") + refresh.reset_mock() + with pytest.raises(snap.ConnectionError): + workload.install_snap_package(revision="42", refresh=refresh) + ensure.assert_not_called() + refresh.update_snap_revision.assert_not_called() + hold.assert_not_called() + + with patch("platform.machine", return_value="missingarch"), pytest.raises(KeyError): + workload.install_snap_package(revision=None) + ensure.assert_not_called() + hold.assert_not_called() @pytest.mark.parametrize("present,refreshing", [(False, False), (True, False), (True, True)]) @@ -235,40 +238,78 @@ def test_install_snap_package_configures_oom_before_install( refresh_versions_dir, present, refreshing ): with ( - patch("single_kernel_postgresql.workload.vm.snap.SnapCache") as cache, + patch("single_kernel_postgresql.workload.vm.snap.list_one") as installed, patch( - "single_kernel_postgresql.workload.vm.ensure_snap_oom_protection", - return_value=-898, + "single_kernel_postgresql.workload.vm.snap.ensure_installed", return_value=False + ) as ensure, + patch("single_kernel_postgresql.workload.vm.snap.hold") as hold, + patch("single_kernel_postgresql.workload.vm.snap.start") as start, + patch("single_kernel_postgresql.workload.vm.snap.restart") as restart, + patch("single_kernel_postgresql.workload.vm.snap.stop") as stop, + patch( + "single_kernel_postgresql.workload.vm.ensure_snap_oom_protection", return_value=-898 ) as protect, ): + if not present: + installed.side_effect = snap.NotInstalledError( + "missing", kind="snap-not-found", value="charmed-postgresql" + ) calls = Mock() calls.attach_mock(protect, "protect") - calls.attach_mock(cache, "cache") - package = cache.return_value.__getitem__.return_value - package.present = present + calls.attach_mock(installed, "installed") + calls.attach_mock(ensure, "ensure") + calls.attach_mock(hold, "hold") refresh = Mock() if refreshing else None - + if refresh is not None: + calls.attach_mock(refresh.update_snap_revision, "bookkeeping") VMWorkload(".").install_snap_package(revision="416", refresh=refresh) - - assert calls.mock_calls[:2] == [call.protect("charmed-postgresql"), call.cache()] + expected = [call.protect("charmed-postgresql"), call.installed("charmed-postgresql")] if not present or refreshing: - package.ensure.assert_called_once_with(snap.SnapState.Present, revision="416") - else: - package.ensure.assert_not_called() - package.start.assert_not_called() - package.restart.assert_not_called() - package.stop.assert_not_called() + expected.append(call.ensure("charmed-postgresql", revision="416")) + if refreshing: + expected.append(call.bookkeeping()) + expected.append(call.hold("charmed-postgresql")) + assert calls.mock_calls == expected + start.assert_not_called() + restart.assert_not_called() + stop.assert_not_called() def test_install_snap_package_stops_on_oom_failure(refresh_versions_dir): with ( - patch("single_kernel_postgresql.workload.vm.snap.SnapCache") as cache, + patch("single_kernel_postgresql.workload.vm.snap.list_one") as installed, patch( "single_kernel_postgresql.workload.vm.ensure_snap_oom_protection", - side_effect=snap.SnapError("cannot protect"), + side_effect=snap.Error("cannot protect"), ), ): - with pytest.raises(snap.SnapError, match="cannot protect"): + with pytest.raises(snap.Error, match="cannot protect"): VMWorkload(".").install_snap_package(revision="416") - - cache.assert_not_called() + installed.assert_not_called() + + +@pytest.mark.parametrize("present", [True, False]) +def test_vm_workload_present(refresh_versions_dir, present): + with patch("single_kernel_postgresql.workload.vm.snap.list_one") as installed: + if not present: + installed.side_effect = snap.NotInstalledError( + "missing", kind="snap-not-found", value="charmed-postgresql" + ) + assert VMWorkload(".").workload_present is present + installed.assert_called_once_with("charmed-postgresql") + + +@pytest.mark.parametrize( + "error", + [ + snap.ConnectionError("unavailable"), + snap.APIError("query failed", kind="failure", value=None), + ], +) +def test_vm_workload_present_propagates_query_errors(refresh_versions_dir, error): + with ( + patch("single_kernel_postgresql.workload.vm.snap.list_one", side_effect=error), + pytest.raises(type(error)) as caught, + ): + _ = VMWorkload(".").workload_present + assert caught.value is error diff --git a/tests/unit/test_workload_services.py b/tests/unit/test_workload_services.py index c66a13ca..437d8076 100644 --- a/tests/unit/test_workload_services.py +++ b/tests/unit/test_workload_services.py @@ -4,6 +4,7 @@ import logging import signal +from contextlib import contextmanager from subprocess import TimeoutExpired from unittest.mock import Mock, patch @@ -182,13 +183,19 @@ def test_k8s_run_cmd_passes_stdin(substrate, workload): # --- service control: VM +@contextmanager def _mock_vm_snap(**services): - """Patch SnapCache in the VM workload module with a snap exposing the given services.""" - selected_snap = Mock() - selected_snap.services = services - cache = Mock() - cache.__getitem__ = Mock(return_value=selected_snap) - return patch("single_kernel_postgresql.workload.vm.snap.SnapCache", return_value=cache) + """Supply service state and stub external snap mutations.""" + with ( + patch( + "single_kernel_postgresql.workload.vm.service_states", + return_value={name: info["active"] for name, info in services.items()}, + ), + patch("single_kernel_postgresql.workload.vm.snap.start") as start, + patch("single_kernel_postgresql.workload.vm.snap.stop") as stop, + patch("single_kernel_postgresql.workload.vm.snap.restart") as restart, + ): + yield Mock(start=start, stop=stop, restart=restart) def test_vm_service_control_uses_snap_by_name(substrate, workload): @@ -199,10 +206,14 @@ def test_vm_service_control_uses_snap_by_name(substrate, workload): workload.start_service(PGBACKREST_SERVICE) workload.stop_service(PGBACKREST_SERVICE) workload.restart_service(PGBACKREST_SERVICE) - selected_snap = mock_cache.return_value.__getitem__.return_value - selected_snap.start.assert_called_once_with(services=[PGBACKREST_SERVICE]) - selected_snap.stop.assert_called_once_with(services=[PGBACKREST_SERVICE]) - selected_snap.restart.assert_called_once_with(services=[PGBACKREST_SERVICE]) + selected_snap = mock_cache + selected_snap.start.assert_called_once_with( + "charmed-postgresql", services=[PGBACKREST_SERVICE] + ) + selected_snap.stop.assert_called_once_with("charmed-postgresql", services=[PGBACKREST_SERVICE]) + selected_snap.restart.assert_called_once_with( + "charmed-postgresql", services=[PGBACKREST_SERVICE] + ) def _patroni_cmdline(): @@ -245,7 +256,7 @@ def test_vm_reload_pgbackrest_sends_sighup_to_daemon(mock_iter, mock_kill, subst mock_iter.return_value = [vanished, process] with _mock_vm_snap(**{PGBACKREST_SERVICE: {"active": True}}) as mock_cache: workload.reload_service(PGBACKREST_SERVICE) - selected_snap = mock_cache.return_value.__getitem__.return_value + selected_snap = mock_cache selected_snap.restart.assert_not_called() mock_kill.assert_called_once_with(4242, signal.SIGHUP) @@ -265,7 +276,7 @@ def test_vm_reload_running_service_without_daemon_skips( caplog.at_level(logging.WARNING), ): workload.reload_service(PGBACKREST_SERVICE) - selected_snap = mock_cache.return_value.__getitem__.return_value + selected_snap = mock_cache selected_snap.restart.assert_not_called() mock_kill.assert_not_called() assert "Unable to find pgbackrest-service pid. Skipping reload" in caplog.text @@ -277,8 +288,10 @@ def test_vm_reload_stopped_service_restarts(substrate, workload): return with _mock_vm_snap(**{PGBACKREST_SERVICE: {"active": False}}) as mock_cache: workload.reload_service(PGBACKREST_SERVICE) - selected_snap = mock_cache.return_value.__getitem__.return_value - selected_snap.restart.assert_called_once_with(services=[PGBACKREST_SERVICE]) + selected_snap = mock_cache + selected_snap.restart.assert_called_once_with( + "charmed-postgresql", services=[PGBACKREST_SERVICE] + ) @pytest.mark.parametrize( @@ -297,15 +310,50 @@ def test_vm_service_is_running(substrate, workload, services, expected): assert workload.service_is_running(PGBACKREST_SERVICE) is expected -def test_vm_service_is_running_snap_error_reads_as_not_running(substrate, workload): +def test_vm_is_patroni_running_selects_patroni(substrate, workload): if substrate == Substrates.K8S: pytest.skip("VM only") - return with patch( - "single_kernel_postgresql.workload.vm.snap.SnapCache", - side_effect=snap.SnapNotFoundError("no snap"), + "single_kernel_postgresql.workload.vm.service_states", + return_value={PGBACKREST_SERVICE: False, "patroni": True}, ): - assert workload.service_is_running(PGBACKREST_SERVICE) is False + assert workload.is_patroni_running() is True + + +@pytest.mark.parametrize( + "services,expected", + [ + pytest.param({"patroni": False}, True, id="stopped"), + pytest.param({}, False, id="missing"), + ], +) +def test_vm_service_exists(substrate, workload, services, expected): + if substrate == Substrates.K8S: + pytest.skip("VM only") + with patch("single_kernel_postgresql.workload.vm.service_states", return_value=services): + assert workload.service_exists("patroni") is expected + + +@pytest.mark.parametrize("probe", ["is_patroni_running", "service_exists", "service_is_running"]) +@pytest.mark.parametrize( + "error", + [ + snap.NotInstalledError("missing", kind="snap-not-found", value="charmed-postgresql"), + snap.ConnectionError("unavailable"), + snap.APIError("query failed", kind="failure", value=None), + ], +) +def test_vm_service_probe_error_policy(substrate, workload, probe, error): + if substrate == Substrates.K8S: + pytest.skip("VM only") + args = () if probe == "is_patroni_running" else ("patroni",) + with patch("single_kernel_postgresql.workload.vm.service_states", side_effect=error): + if isinstance(error, snap.NotInstalledError): + assert getattr(workload, probe)(*args) is False + else: + with pytest.raises(type(error)) as caught: + getattr(workload, probe)(*args) + assert caught.value is error # --- service control: K8s diff --git a/uv.lock b/uv.lock index d1647dc0..5428291b 100644 --- a/uv.lock +++ b/uv.lock @@ -298,14 +298,11 @@ wheels = [ [[package]] name = "charmlibs-snap" -version = "1.0.1.post0" +version = "2.0.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "opentelemetry-api" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/85/33/5043f1dd01e485e1c855516e41694fae48f48e94dd52e6081e5b61eee649/charmlibs_snap-1.0.1.post0.tar.gz", hash = "sha256:1e8da752ee405aa981665da8c4772016236baf80d2d902b02ec8c1c640fb2844", size = 29393, upload-time = "2026-06-16T05:39:54.911Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/f1/b1af81b093f4b94f957a2d2efb20b78975f615a6384d44917c633f77ce82/charmlibs_snap-2.0.0.tar.gz", hash = "sha256:82bc863919614436bf4e8e38cedaa4d809c3d4e1eedab10b2eeb97006116cd29", size = 125387, upload-time = "2026-09-02T21:32:27.485Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9c/71/fa658e05748a2ffd1185aeec43aefb286c33c2767e28919f0445b464244a/charmlibs_snap-1.0.1.post0-py3-none-any.whl", hash = "sha256:655041096952c63e92c8d25a6183149f0594d4888be4be62a9635cb96897aa01", size = 15416, upload-time = "2026-06-16T05:39:53.629Z" }, + { url = "https://files.pythonhosted.org/packages/60/d9/65d7e73532c50f2533b8f1a735894b5d260202f60d5ab05e367b93382e13/charmlibs_snap-2.0.0-py3-none-any.whl", hash = "sha256:6e479163ede22f9ab4b66adead2d4ce4cdc6eb77f36f88c50c4d3d3b075da040", size = 38470, upload-time = "2026-09-02T21:32:26.129Z" }, ] [[package]] @@ -1234,7 +1231,7 @@ wheels = [ [[package]] name = "postgresql-charms-single-kernel" -version = "16.3.25" +version = "16.3.26" source = { editable = "." } dependencies = [ { name = "tenacity", version = "9.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, @@ -1309,7 +1306,7 @@ requires-dist = [ { name = "charm-refresh", marker = "python_full_version >= '3.12' and extra == 'postgresql'" }, { name = "charmlibs-interfaces-tls-certificates", marker = "python_full_version >= '3.12' and extra == 'postgresql'", specifier = ">=1.8.3" }, { name = "charmlibs-pathops", marker = "python_full_version >= '3.12' and extra == 'postgresql'", specifier = ">=1.0.1" }, - { name = "charmlibs-snap", marker = "python_full_version >= '3.12' and extra == 'vm'", specifier = ">=1.0.1,<2" }, + { name = "charmlibs-snap", marker = "python_full_version >= '3.12' and extra == 'vm'", specifier = ">=2.0.0,<3" }, { name = "charmlibs-systemd", marker = "python_full_version >= '3.12' and extra == 'vm'", specifier = ">=1.0.0.post0" }, { name = "cosl", marker = "python_full_version >= '3.12' and extra == 'k8s'", specifier = ">=0.0.53" }, { name = "cosl", marker = "python_full_version >= '3.12' and extra == 'vm'", specifier = ">=0.0.53" },