driver / lint (pull_request) Successful in 14s
driver / standard (pull_request) Successful in 16s
driver / types (pull_request) Successful in 1m5s
driver / test (3.13) (pull_request) Successful in 1m4s
driver / test (3.12) (pull_request) Successful in 1m10s
driver / lowest (pull_request) Successful in 31s
driver / build (pull_request) Successful in 30s
driver / security (pull_request) Successful in 1m0s
CI / driver (pull_request) Successful in 2m20s
driver / publish (pull_request) Skipped
A second driver in this package, ProxmoxBackupDriver. Its API and web UI are on 8007, not on PVE's 8006, and its node is always localhost; open() proves the login with GET /version, so a bad token fails there. Roles: BackupServerDriver (napalm-device-types 4.25.0) first, then StorageDriver for the disks and ZFS pools the server manages. It reads datastores, the backup groups of every namespace with their newest snapshot, a group's snapshots, the GC, verify, prune, sync and tape jobs with how their last run ended, and the remotes without their secrets; it starts garbage collection and jobs, verifies, protects and deletes snapshots, and follows the tasks. As a host it reports facts, interfaces, CPU and memory, disks, pools, its pbs-subscription and the same packages, updates, host readers and sshd hardening as a PVE node. A privilege-separated token without an ACL entry gets an empty list from PBS, not a refusal, so every read checks /access/permissions and raises PermissionError. A removable datastore that is not mounted is reported as unmounted and left out of the group listing. The fixture is what a PBS 4.2 answered, sanitised; groups, snapshots and jobs it did not have yet follow the API schema.
97 lines
3.4 KiB
Python
97 lines
3.4 KiB
Python
"""A stand-in for proxmoxer's PBS client, answering from recorded responses.
|
|
|
|
``tests/fixtures/pbs_api.json`` holds what a real Proxmox Backup Server 4.2
|
|
answered (sanitised). Paths a test adds on top -- backup groups, snapshots and
|
|
jobs, which that server did not have yet -- follow the shapes of the PBS API
|
|
schema (``pbs.proxmox.com/docs/api-viewer``).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import copy
|
|
import json
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from proxmoxer.core import ResourceException
|
|
|
|
RECORDED: dict[str, Any] = json.loads(
|
|
(Path(__file__).parent / "fixtures" / "pbs_api.json").read_text()
|
|
)
|
|
|
|
|
|
def _key(path: str, params: dict[str, Any]) -> str:
|
|
query = "&".join(f"{k}={params[k]}" for k in sorted(params))
|
|
return f"{path.strip('/')}?{query}" if query else path.strip("/")
|
|
|
|
|
|
class _Resource:
|
|
"""proxmoxer's chained form: ``api.nodes("localhost").status.get()``."""
|
|
|
|
def __init__(self, api: FakePbsApi, path: str) -> None:
|
|
self._api, self._path = api, path
|
|
|
|
def __getattr__(self, name: str) -> _Resource:
|
|
return _Resource(self._api, f"{self._path}/{name}")
|
|
|
|
def __call__(self, segment: str) -> _Resource:
|
|
return _Resource(self._api, f"{self._path}/{segment}")
|
|
|
|
def get(self, **params: Any) -> Any:
|
|
return self._api.get(self._path, **params)
|
|
|
|
def post(self, **params: Any) -> Any:
|
|
return self._api.post(self._path, **params)
|
|
|
|
|
|
class FakePbsApi:
|
|
"""``get``/``post``/``put``/``delete`` by path, like ``ProxmoxAPI.get("admin/gc")``,
|
|
or chained, like ``ProxmoxAPI.nodes("localhost").status.get()``.
|
|
|
|
A response is looked up as ``"path?k=v&..."`` first, then as ``"path"``. A
|
|
value that is an exception is raised. Every call is recorded in ``calls``.
|
|
"""
|
|
|
|
def __init__(self, **overrides: Any) -> None:
|
|
self.responses: dict[str, Any] = copy.deepcopy(RECORDED)
|
|
self.responses.update(overrides)
|
|
self.calls: list[tuple[str, str, dict[str, Any]]] = []
|
|
|
|
def _answer(self, method: str, path: str, params: dict[str, Any]) -> Any:
|
|
self.calls.append((method, path.strip("/"), params))
|
|
for key in (f"{method} {_key(path, params)}", f"{method} {path.strip('/')}"):
|
|
if key in self.responses:
|
|
return self._value(self.responses[key])
|
|
if method == "GET":
|
|
for key in (_key(path, params), path.strip("/")):
|
|
if key in self.responses:
|
|
return self._value(self.responses[key])
|
|
raise ResourceException(404, "Not Found", f"no recorded answer for {method} {path}")
|
|
|
|
@staticmethod
|
|
def _value(value: Any) -> Any:
|
|
if isinstance(value, Exception):
|
|
raise value
|
|
return copy.deepcopy(value)
|
|
|
|
def __getattr__(self, name: str) -> _Resource:
|
|
if name.startswith("_"):
|
|
raise AttributeError(name)
|
|
return _Resource(self, name)
|
|
|
|
def get(self, path: str, **params: Any) -> Any:
|
|
return self._answer("GET", path, params)
|
|
|
|
def post(self, path: str, **params: Any) -> Any:
|
|
return self._answer("POST", path, params)
|
|
|
|
def put(self, path: str, **params: Any) -> Any:
|
|
return self._answer("PUT", path, params)
|
|
|
|
def delete(self, path: str, **params: Any) -> Any:
|
|
return self._answer("DELETE", path, params)
|
|
|
|
|
|
def forbidden() -> ResourceException:
|
|
return ResourceException(403, "Forbidden", "permission check failed")
|