driver / standard (pull_request) Successful in 14s
driver / lint (pull_request) Successful in 14s
driver / types (pull_request) Successful in 56s
driver / test (3.12) (pull_request) Successful in 1m2s
driver / test (3.13) (pull_request) Successful in 59s
driver / lowest (pull_request) Successful in 32s
driver / build (pull_request) Successful in 31s
driver / security (pull_request) Successful in 1m11s
CI / driver (pull_request) Successful in 2m41s
driver / publish (pull_request) Skipped
netOrk keeps one list of NTP servers and a time zone per site and aligns a device that differs (NetOrk/netork#2360, #2365). Both drivers now implement napalm-device-types' TimeSyncMixin (4.35.0) and write both values. Neither API keeps time servers: /nodes/{node}/time knows only the zone, and both products run chrony on Debian. The servers are therefore PosixTimeSyncMixin's, over the driver's existing SSH session (run_command, root): read from chrony's configuration, written to /etc/chrony/sources.d/netork.sources with every other source commented out, then a reload or a restart of chrony. The zone is read with them from the host (timedatectl: the zone the clock really runs in), and from GET /nodes/{node}/time only where the host names none. It is written through PUT /nodes/{node}/time rather than timedatectl set-timezone: Proxmox's own call validates the name and keeps /etc/timezone, which its web UI and API show, in step with /etc/localtime. One device is one node: in a PVE cluster every node has its own clock, and only the node this connection resolved is read and written. get_ntp_servers() read GET /nodes/{node}/ntp, a path Proxmox VE does not have, so it always reported no servers. It now reports what get_time_sync() reads, on the backup server too.
100 lines
3.5 KiB
Python
100 lines
3.5 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)
|
|
|
|
def put(self, **params: Any) -> Any:
|
|
return self._api.put(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")
|