diff --git a/CHANGELOG.md b/CHANGELOG.md index 26bd065..517afe0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,19 @@ recorded here; their history is the git log. ## [Unreleased] +### Added +- `BackupServerDriver` (`ROLE = "backup_server"`), a role base for backup servers such as + Proxmox Backup Server (#82). It declares `get_backup_datastores`, `get_backup_groups` + (each group with its newest snapshot), `get_backup_snapshots`, `get_backup_jobs` + (garbage collection, verify, prune, sync and tape in one list) and `get_backup_remotes`, + and the actions `start_garbage_collection`, `run_backup_job`, `verify_backup_snapshot`, + `set_backup_snapshot_protected` and `delete_backup_snapshot`, which return a task to + follow with `get_backup_task`. The shapes live in `napalm_device_types.backups`. A + server that manages its own disks lists `StorageDriver` as its second role. +- `ClusterStorageDict.backup_server` (optional): which backup server, datastore and + namespace a hypervisor's backup storage writes to, with the certificate fingerprint it + pins, so an application can tie a server's backup groups to a cluster's guests. + ## [4.24.0] - 2026-11-02 ### Added diff --git a/README.md b/README.md index 6cbf721..efb6af7 100644 --- a/README.md +++ b/README.md @@ -47,6 +47,18 @@ UUID and NIC MACs -- what ties the BMC to the host it manages. Its sensors come NAPALM's `get_environment`, with `cpu` and `memory` empty, since a BMC does not know the host OS's load; it has no `HealthMetricsMixin` (SNMP) and no command channel. +A backup server (Proxmox Backup Server) is a role of its own too, `BackupServerDriver` +(`backup_server`). Its datastores, the backup groups in them (each with its newest +snapshot), its jobs (garbage collection, verify, prune, sync, tape) and its remotes have +no counterpart in `StorageDriver`, so they are not bent into pools, volumes and +replication jobs. A server that also manages its own disks and pools lists +`StorageDriver` second: `class ProxmoxBackupDriver(BackupServerDriver, StorageDriver, ...)`. +Its actions (garbage collection, running a job, verifying, protecting or deleting a +snapshot) start a task and return its id at once; `get_backup_task` follows it. On the +hypervisor side, a cluster storage that writes to a backup server says which one +(`ClusterStorageDict.backup_server`: server, port, datastore, namespace, fingerprint), so +an application can tie the server's groups to the cluster's guests. + ### Role bases declare; they never implement **A role base must not contain a single runtime method — not even a @@ -461,6 +473,7 @@ Requires Python ≥ 3.12 (tested up to 3.13) and NAPALM ≥ 4.0. | `PhoneDriver` | IP telephony endpoints | Yealink | | `MediaDriver` | Speakers, streamers, media renderers | Sonos, Chromecast | | `ManagementControllerDriver` | Server baseboard management controllers | Supermicro BMC, Dell iDRAC, HPE iLO, Lenovo XCC | +| `BackupServerDriver` | Backup servers: datastores, backup groups, GC/verify/prune/sync/tape jobs | Proxmox Backup Server | Mixins that come with the classes above: `PingSweepMixin` (subnet sweeps, in every driver through `DeviceTypeDriver`) and `DhcpServerMixin` (static DHCP diff --git a/docs/STRUCTURE.md b/docs/STRUCTURE.md index 68c86f7..ffd6bda 100644 --- a/docs/STRUCTURE.md +++ b/docs/STRUCTURE.md @@ -35,7 +35,7 @@ application SNMP polling, ping sweeps, discovery scoring, guest | Kind | Rule | Modules | |---|---|---| -| **Role** | Declares only, under `TYPE_CHECKING`. No runtime method. | `access_point`, `switch`, `firewall`, `hypervisor`, `os`, `storage`, `phone`, `media`, `residential_gateway`, `management_controller` | +| **Role** | Declares only, under `TYPE_CHECKING`. No runtime method. | `access_point`, `switch`, `firewall`, `hypervisor`, `os`, `storage`, `phone`, `media`, `residential_gateway`, `management_controller`, `backup_server` | | **Capability** | Declares only. | `packages`, `services`, `updates`, `nat_vpn`, `mac_acl`, `config_lifecycle`, `interface_filter`, `host_reboot` | | **Template** | A concrete method that runs a fixed sequence of abstract steps. A driver implements the steps, or overrides the whole method when its device does it in one go. All values come from the caller. | the fix routines below | | **Contract types** | Interfaces and data shapes other packages implement or fill. | `CommandChannelMixin`, `CommandResult`, `ByteStream`; the declaration of `ContainerEngineMixin`; the reader mixins' public method declarations; the SNMP profile type; `models` | diff --git a/napalm_device_types/__init__.py b/napalm_device_types/__init__.py index 9c7de80..822d958 100644 --- a/napalm_device_types/__init__.py +++ b/napalm_device_types/__init__.py @@ -22,6 +22,7 @@ driver do X". Role bases -- what a device *is*: * :class:`~napalm_device_types.access_point.AccessPointDriver` +* :class:`~napalm_device_types.backup_server.BackupServerDriver` * :class:`~napalm_device_types.switch.SwitchDriver` * :class:`~napalm_device_types.firewall.FirewallDriver` * :class:`~napalm_device_types.hypervisor.HypervisorDriver` @@ -78,6 +79,22 @@ from napalm_device_types.apt_proxy import ( same_proxy_url, ) from napalm_device_types.arp import ARP_AGE_UNKNOWN +from napalm_device_types.backup_server import BackupServerDriver +from napalm_device_types.backups import ( + BACKUP_JOB_KINDS, + BackupDatastoreDict, + BackupGroupDict, + BackupJobKind, + BackupRemoteDict, + BackupRunState, + BackupServerJobDict, + BackupServerRefDict, + BackupSnapshotDict, + BackupSnapshotRefDict, + BackupTaskDict, + BackupTaskStatusDict, + BackupVerifyState, +) from napalm_device_types.base import DeviceTypeDriver, FingerprintRule, PortSpec, rules_max_weight from napalm_device_types.channel import ( ByteStream, @@ -256,6 +273,19 @@ from napalm_device_types.vm_migration import MigrationPreflightDict from napalm_device_types.vm_stop_request import VmStopRequestMixin __all__ = [ + "BACKUP_JOB_KINDS", + "BackupDatastoreDict", + "BackupGroupDict", + "BackupJobKind", + "BackupRemoteDict", + "BackupRunState", + "BackupServerJobDict", + "BackupServerRefDict", + "BackupSnapshotDict", + "BackupSnapshotRefDict", + "BackupTaskDict", + "BackupTaskStatusDict", + "BackupVerifyState", "BackupDict", "BackupJobDict", "ClusterDict", @@ -295,6 +325,7 @@ __all__ = [ "SnmpMemorySpec", "SnmpValueSpec", "AccessPointDriver", + "BackupServerDriver", "ByteStream", "CommandChannelMixin", "CommandResult", diff --git a/napalm_device_types/backup_server.py b/napalm_device_types/backup_server.py new file mode 100644 index 0000000..7de8980 --- /dev/null +++ b/napalm_device_types/backup_server.py @@ -0,0 +1,238 @@ +""" +Abstract base class for backup server drivers. + +Usage:: + + from napalm_device_types import BackupServerDriver, StorageDriver + + class ProxmoxBackupDriver(BackupServerDriver, StorageDriver): + def get_backup_datastores(self): + ... +""" + +from typing import TYPE_CHECKING + +from napalm_device_types.base import DeviceTypeDriver + +if TYPE_CHECKING: # pragma: no cover - for type checkers only + from napalm_device_types.backups import ( + BackupDatastoreDict, + BackupGroupDict, + BackupJobKind, + BackupRemoteDict, + BackupServerJobDict, + BackupSnapshotDict, + BackupSnapshotRefDict, + BackupTaskDict, + BackupTaskStatusDict, + ) + + +class BackupServerDriver(DeviceTypeDriver): + """ + Abstract intermediate driver for backup servers (e.g. Proxmox Backup + Server): the device hypervisors and hosts write their backups to. + + A backup server keeps its backups in datastores, one group per source (a + VM, a container, a host) and one snapshot per backup run, and keeps them + healthy with scheduled jobs: garbage collection, verify, prune, sync with + other servers and tape. None of that is a storage pool, a volume or a + replication job, so it is not modelled through ``StorageDriver``. A server + that also manages its own disks and pools lists ``StorageDriver`` as a + second role, after this one. + + The actions start a task on the server and return at once with its id; + :meth:`get_backup_task` follows it. + """ + + #: Stable key netOrk exposes as ``device_class``. The order in which a + #: driver lists its role bases is the ranking; see + #: :func:`napalm_device_types.roles.primary_role_of`. + ROLE: str = "backup_server" + TYPE_LABEL: str = "Backup Server" + + if TYPE_CHECKING: + # ------------------------------------------------------------------ + # Read + # ------------------------------------------------------------------ + + def get_backup_datastores(self) -> list[BackupDatastoreDict]: + """ + Returns the server's datastores with their usage. + + Example:: + + [ + { + "name": "store1", + "path": "/mnt/datastore/store1", + "backend": "local", + "total": 4000787030016, + "used": 1529008357376, + "available": 2471778672640, + "estimated_full": 1798761600, + "maintenance": None, + "comment": None, + }, + ] + + :raises Exception: when the server could not be read; never an + empty list for a failed read. + """ + ... + + def get_backup_groups(self, datastore: str = "") -> list[BackupGroupDict]: + """ + Returns the backup groups of every namespace of *datastore*, or of + every datastore when it is empty, each with its newest snapshot + only. :meth:`get_backup_snapshots` lists all of a group's. + + Example:: + + [ + { + "datastore": "store1", + "namespace": "", + "type": "vm", + "id": "101", + "owner": "backup@pbs", + "count": 14, + "newest": { + "time": 1793660400, + "size": 34359738368, + "verify": "ok", + "protected": False, + "comment": "web-01", + }, + "oldest_time": 1792537200, + "comment": None, + }, + ] + + :raises Exception: when the server could not be read. + """ + ... + + def get_backup_snapshots( + self, datastore: str, namespace: str, group_type: str, group_id: str + ) -> list[BackupSnapshotDict]: + """ + Returns every snapshot of one group, newest first. + + :param namespace: ``""`` for the datastore's root. + :raises ValueError: when the datastore or the group does not exist. + """ + ... + + def get_backup_jobs(self) -> list[BackupServerJobDict]: + """ + Returns the server's scheduled jobs of every kind, garbage + collection included (one per datastore, ``id`` = the datastore). + + Example:: + + [ + { + "id": "store1", + "kind": "gc", + "datastore": "store1", + "namespace": None, + "schedule": "daily", + "enabled": True, + "last_run": 1793664000, + "last_state": "ok", + "last_error": None, + "next_run": 1793750400, + "remote": None, + "direction": None, + "comment": None, + }, + { + "id": "offsite", + "kind": "sync", + "datastore": "store1", + "namespace": "", + "schedule": "sat 03:00", + "enabled": True, + "last_run": 1793502000, + "last_state": "error", + "last_error": "connection refused", + "next_run": 1794106800, + "remote": "pbs-offsite", + "direction": "push", + "comment": None, + }, + ] + + :raises Exception: when the server could not be read. + """ + ... + + def get_backup_remotes(self) -> list[BackupRemoteDict]: + """ + Returns the other backup servers this one syncs with, without their + secrets. + + :raises Exception: when the server could not be read. + """ + ... + + # ------------------------------------------------------------------ + # Actions + # ------------------------------------------------------------------ + + def start_garbage_collection(self, datastore: str) -> BackupTaskDict: + """ + Starts garbage collection on *datastore*. + + :raises ValueError: when the datastore does not exist. + :raises RuntimeError: when the server refuses (e.g. one is running). + """ + ... + + def run_backup_job(self, kind: BackupJobKind, job_id: str) -> BackupTaskDict: + """ + Runs a scheduled job now, outside its schedule. + + :param kind: a :data:`~napalm_device_types.backups.BackupJobKind`; + ``"gc"`` runs the datastore named *job_id*'s garbage collection. + :raises ValueError: when there is no such job. + :raises RuntimeError: when the server refuses. + """ + ... + + def verify_backup_snapshot(self, snapshot: BackupSnapshotRefDict) -> BackupTaskDict: + """ + Verifies one snapshot now. + + :raises ValueError: when the snapshot does not exist. + """ + ... + + def set_backup_snapshot_protected( + self, snapshot: BackupSnapshotRefDict, protected: bool + ) -> None: + """ + Protects a snapshot from pruning and deletion, or lifts that. + + :raises ValueError: when the snapshot does not exist. + """ + ... + + def delete_backup_snapshot(self, snapshot: BackupSnapshotRefDict) -> None: + """ + Deletes one snapshot. The data is gone once garbage collection has + run; there is no undo. + + :raises ValueError: when the snapshot does not exist. + :raises RuntimeError: when it is protected. + """ + ... + + def get_backup_task(self, task: str) -> BackupTaskStatusDict: + """ + Returns the state and the log so far of a task an action started. + + :raises ValueError: when the server does not know the task. + """ + ... diff --git a/napalm_device_types/backups.py b/napalm_device_types/backups.py new file mode 100644 index 0000000..b6763a0 --- /dev/null +++ b/napalm_device_types/backups.py @@ -0,0 +1,119 @@ +"""The shapes of a backup server (``BackupServerDriver``). + +Apart from ``models.py``, which is over the file size limit. A value the +platform does not report is None; it is never guessed. +""" + +from typing import Literal, TypedDict, get_args + +#: What a backup server's jobs do. Garbage collection is one of them: it has a +#: schedule and a last run like the others. +BackupJobKind = Literal["gc", "verify", "prune", "sync", "tape"] +BACKUP_JOB_KINDS: tuple[str, ...] = get_args(BackupJobKind) + +#: How a job's or a task's run ended; "running" while it has not. +BackupRunState = Literal["ok", "warning", "error", "running"] + +#: The outcome of the last verification of a snapshot. +BackupVerifyState = Literal["ok", "failed"] + + +class BackupDatastoreDict(TypedDict): + """A datastore: where a backup server keeps its backups.""" + + name: str + path: str | None # local path; for an object-store backend the local cache, if any + backend: str # "local", "s3", "removable", ... as the platform names it + total: int | None # bytes + used: int | None # bytes + available: int | None # bytes + estimated_full: int | None # unix seconds the platform expects it to be full + maintenance: str | None # "read-only", "offline", ...; None when in service + comment: str | None + + +class BackupSnapshotDict(TypedDict): + """One backup of a group: the state of its source at one time.""" + + time: int # unix seconds the backup was taken + size: int | None # bytes + verify: BackupVerifyState | None # None: never verified + protected: bool # exempt from pruning and deletion + comment: str | None + + +class BackupGroupDict(TypedDict): + """The backups of one source (a VM, a container, a host) in one namespace.""" + + datastore: str + namespace: str # "" for the datastore's root + type: str # "vm", "ct", "host" + id: str # the guest's id ("101") or the host's name + owner: str | None # the account that writes the group's backups + count: int # snapshots in the group + newest: BackupSnapshotDict | None # None for a group without a snapshot + oldest_time: int | None # unix seconds of the oldest snapshot + comment: str | None + + +class BackupSnapshotRefDict(TypedDict): + """Names one snapshot, for an action on it.""" + + datastore: str + namespace: str # "" for the datastore's root + group_type: str # BackupGroupDict.type + group_id: str # BackupGroupDict.id + time: int # BackupSnapshotDict.time + + +class BackupServerJobDict(TypedDict): + """A scheduled job of a backup server.""" + + id: str # for "gc", the datastore's name + kind: BackupJobKind + datastore: str | None + namespace: str | None + schedule: str | None # as the platform writes it: "daily", "sat 02:00", "*:0/30" + enabled: bool + last_run: int | None # unix seconds the last run ended (or started, while running) + last_state: BackupRunState | None # None: never ran + last_error: str | None + next_run: int | None # unix seconds + remote: str | None # a sync job's BackupRemoteDict.name + direction: Literal["pull", "push"] | None # a sync job's + comment: str | None + + +class BackupRemoteDict(TypedDict): + """Another backup server this one syncs with. Never its secret.""" + + name: str + host: str + port: int | None + fingerprint: str | None # of the remote's TLS certificate + auth_id: str | None # the account the sync logs in as + comment: str | None + + +class BackupTaskDict(TypedDict): + """A task an action started on the server, to follow with ``get_backup_task``.""" + + task: str # the platform's task id + + +class BackupTaskStatusDict(TypedDict): + task: str + running: bool + state: BackupRunState | None # "running" while it runs + error: str | None + log: list[str] # the task's log lines so far + + +class BackupServerRefDict(TypedDict): + """Which backup server and datastore a hypervisor's backup storage writes to.""" + + server: str # host name or address, as the hypervisor has it configured + port: int | None + datastore: str + namespace: str | None + fingerprint: str | None # of the server's TLS certificate, as the hypervisor pins it diff --git a/napalm_device_types/clusters.py b/napalm_device_types/clusters.py index cbc77ab..56c82de 100644 --- a/napalm_device_types/clusters.py +++ b/napalm_device_types/clusters.py @@ -5,6 +5,8 @@ Apart from ``models.py``, which is over the file size limit. from typing import NotRequired, TypedDict +from napalm_device_types.backups import BackupServerRefDict + class ClusterNodeDict(TypedDict): """One host of a cluster, as its cluster sees it. A value the platform does not @@ -34,6 +36,9 @@ class ClusterStorageDict(TypedDict): nodes: list[str] # the nodes it is available on total: int | None # bytes; None where the platform does not report it used: int | None # bytes + # A backup storage that writes to a backup server: which one. Left out for every + # other storage; None where the platform does not say. + backup_server: NotRequired[BackupServerRefDict | None] class ClusterNetworkDict(TypedDict): diff --git a/tests/test_backup_server.py b/tests/test_backup_server.py new file mode 100644 index 0000000..a4279e2 --- /dev/null +++ b/tests/test_backup_server.py @@ -0,0 +1,234 @@ +"""A backup server is a role of its own (NAPALM/napalm-device-types#82). + +What makes a device a backup server -- datastores, the backup groups in them, +the jobs that keep them (garbage collection, verify, prune, sync, tape) and the +remotes it syncs with -- has no counterpart in ``StorageDriver``. A backup +server that also manages its own disks lists ``StorageDriver`` as a second role. + +The declarations sit under ``TYPE_CHECKING`` (see test_role_contracts), so the +signatures are read from the source rather than from the class. +""" + +from __future__ import annotations + +import ast +import inspect +from typing import NotRequired, get_args, get_type_hints + +import pytest + +import napalm_device_types.backup_server as backup_server_module +from napalm_device_types import ( + BACKUP_JOB_KINDS, + BackupDatastoreDict, + BackupGroupDict, + BackupRemoteDict, + BackupServerDriver, + BackupServerJobDict, + BackupServerRefDict, + BackupSnapshotDict, + BackupSnapshotRefDict, + BackupTaskDict, + BackupTaskStatusDict, + ClusterStorageDict, + OSDriver, + StorageDriver, +) +from napalm_device_types.backups import BackupJobKind, BackupRunState, BackupVerifyState +from napalm_device_types.roles import primary_role_of, role_keys_of + + +def _declared(name: str) -> ast.FunctionDef: + tree = ast.parse(inspect.getsource(backup_server_module)) + for node in ast.walk(tree): + if isinstance(node, ast.FunctionDef) and node.name == name: + return node + raise AssertionError(f"BackupServerDriver does not declare {name}()") + + +def _signature(name: str) -> tuple[list[str], str]: + fn = _declared(name) + params = ast.unparse(fn.args).split(", ")[1:] + return params, ast.unparse(fn.returns) if fn.returns else "" + + +class TestRole: + def test_role_key_and_label(self): + assert vars(BackupServerDriver)["ROLE"] == "backup_server" + assert BackupServerDriver.TYPE_LABEL == "Backup Server" + + def test_backup_server_first_storage_second(self): + """A PBS manages its disks and ZFS pools too; that part is storage.""" + + class Pbs(BackupServerDriver, StorageDriver, OSDriver): + pass + + assert role_keys_of(Pbs) == ["backup_server", "storage", "linux"] + assert primary_role_of(Pbs) == "backup_server" + + +class TestDeclarations: + @pytest.mark.parametrize( + ("name", "params", "returns"), + [ + ("get_backup_datastores", [], "list[BackupDatastoreDict]"), + ("get_backup_groups", ["datastore: str=''"], "list[BackupGroupDict]"), + ( + "get_backup_snapshots", + ["datastore: str", "namespace: str", "group_type: str", "group_id: str"], + "list[BackupSnapshotDict]", + ), + ("get_backup_jobs", [], "list[BackupServerJobDict]"), + ("get_backup_remotes", [], "list[BackupRemoteDict]"), + ("start_garbage_collection", ["datastore: str"], "BackupTaskDict"), + ("run_backup_job", ["kind: BackupJobKind", "job_id: str"], "BackupTaskDict"), + ("verify_backup_snapshot", ["snapshot: BackupSnapshotRefDict"], "BackupTaskDict"), + ( + "set_backup_snapshot_protected", + ["snapshot: BackupSnapshotRefDict", "protected: bool"], + "None", + ), + ("delete_backup_snapshot", ["snapshot: BackupSnapshotRefDict"], "None"), + ("get_backup_task", ["task: str"], "BackupTaskStatusDict"), + ], + ) + def test_declared_with_its_signature(self, name, params, returns): + got_params, got_returns = _signature(name) + assert [p.replace(" ", "") for p in got_params] == [p.replace(" ", "") for p in params] + assert got_returns == returns + + @pytest.mark.parametrize( + "name", + [ + "get_backup_datastores", + "get_backup_groups", + "get_backup_snapshots", + "get_backup_jobs", + "get_backup_remotes", + "start_garbage_collection", + "run_backup_job", + "verify_backup_snapshot", + "set_backup_snapshot_protected", + "delete_backup_snapshot", + "get_backup_task", + ], + ) + def test_absent_until_a_driver_implements_it(self, name): + assert not hasattr(BackupServerDriver, name) + + def test_every_declaration_has_a_docstring(self): + tree = ast.parse(inspect.getsource(backup_server_module)) + missing = [ + n.name + for n in ast.walk(tree) + if isinstance(n, ast.FunctionDef) and not ast.get_docstring(n) + ] + assert missing == [] + + +class TestShapes: + """Neutral names: nothing here is Proxmox's. A value the platform does not + report is None; it is never guessed.""" + + def test_datastore(self): + assert set(get_type_hints(BackupDatastoreDict)) == { + "name", + "path", + "backend", + "total", + "used", + "available", + "estimated_full", + "maintenance", + "comment", + } + + def test_group_carries_its_newest_snapshot_not_all_of_them(self): + assert set(get_type_hints(BackupGroupDict)) == { + "datastore", + "namespace", + "type", + "id", + "owner", + "count", + "newest", + "oldest_time", + "comment", + } + assert get_type_hints(BackupGroupDict)["newest"] == BackupSnapshotDict | None + + def test_snapshot(self): + assert set(get_type_hints(BackupSnapshotDict)) == { + "time", + "size", + "verify", + "protected", + "comment", + } + assert set(get_args(BackupVerifyState)) == {"ok", "failed"} + + def test_snapshot_reference_names_one_snapshot(self): + assert set(get_type_hints(BackupSnapshotRefDict)) == { + "datastore", + "namespace", + "group_type", + "group_id", + "time", + } + + def test_job_kinds_include_garbage_collection(self): + """GC is a job with a schedule and a last run like the others, so it is + listed with them rather than restated on the datastore.""" + assert set(get_args(BackupJobKind)) == {"gc", "verify", "prune", "sync", "tape"} + assert set(BACKUP_JOB_KINDS) == set(get_args(BackupJobKind)) + + def test_job(self): + assert set(get_type_hints(BackupServerJobDict)) == { + "id", + "kind", + "datastore", + "namespace", + "schedule", + "enabled", + "last_run", + "last_state", + "last_error", + "next_run", + "remote", + "direction", + "comment", + } + assert set(get_args(BackupRunState)) == {"ok", "warning", "error", "running"} + + def test_remote_never_carries_its_secret(self): + fields = set(get_type_hints(BackupRemoteDict)) + assert fields == {"name", "host", "port", "fingerprint", "auth_id", "comment"} + assert not fields & {"password", "secret", "token"} + + def test_task(self): + assert set(get_type_hints(BackupTaskDict)) == {"task"} + assert set(get_type_hints(BackupTaskStatusDict)) == { + "task", + "running", + "state", + "error", + "log", + } + + +class TestClusterStorageNamesItsBackupServer: + """A hypervisor's backup storage says which server and datastore it points + at, so an application can tie the server's groups to the cluster's guests.""" + + def test_backup_server_reference_is_optional_on_a_storage(self): + hints = get_type_hints(ClusterStorageDict, include_extras=True) + assert hints["backup_server"] == NotRequired[BackupServerRefDict | None] + + def test_reference(self): + assert set(get_type_hints(BackupServerRefDict)) == { + "server", + "port", + "datastore", + "namespace", + "fingerprint", + } diff --git a/tests/test_clusters.py b/tests/test_clusters.py index d678669..fb1f4d9 100644 --- a/tests/test_clusters.py +++ b/tests/test_clusters.py @@ -25,6 +25,7 @@ import napalm_device_types.hypervisor as hypervisor_module from napalm_device_types import ( BackupDict, BackupJobDict, + BackupServerRefDict, ClusterDict, ClusterNetworkDict, ClusterNodeDict, @@ -92,7 +93,8 @@ class TestClusterShape: assert "votes" not in ClusterNodeDict.__required_keys__ def test_storage(self): - assert get_type_hints(ClusterStorageDict) == { + hints = get_type_hints(ClusterStorageDict, include_extras=True) + assert hints == { "name": str, "type": str, "shared": bool, @@ -100,7 +102,10 @@ class TestClusterShape: "nodes": list[str], "total": int | None, "used": int | None, + "backup_server": NotRequired[BackupServerRefDict | None], } + # A driver written before backup servers were part of the report stays valid. + assert "backup_server" not in ClusterStorageDict.__required_keys__ def test_network(self): hints = get_type_hints(ClusterNetworkDict, include_extras=True) diff --git a/tests/test_fix_templates.py b/tests/test_fix_templates.py index 6c1adfc..1eb9c3d 100644 --- a/tests/test_fix_templates.py +++ b/tests/test_fix_templates.py @@ -11,6 +11,7 @@ import pytest from napalm_device_types import ( AccessPointDriver, + BackupServerDriver, EnsurePackageMixin, FirewallDriver, HypervisorDriver, @@ -28,7 +29,7 @@ from napalm_device_types import ( ) ROLE_BASES = [ - AccessPointDriver, FirewallDriver, HypervisorDriver, ManagementControllerDriver, MediaDriver, + AccessPointDriver, BackupServerDriver, FirewallDriver, HypervisorDriver, ManagementControllerDriver, MediaDriver, OSDriver, PhoneDriver, ResidentialGatewayDriver, StorageDriver, SwitchDriver, ] # fmt: skip diff --git a/tests/test_role_contracts.py b/tests/test_role_contracts.py index 0c60958..d2baec4 100644 --- a/tests/test_role_contracts.py +++ b/tests/test_role_contracts.py @@ -18,6 +18,7 @@ import pytest from napalm_device_types import ( AccessPointDriver, + BackupServerDriver, DeviceTypeDriver, FirewallDriver, HypervisorDriver, @@ -33,6 +34,7 @@ from napalm_device_types.roles import primary_role_of, roles_of ROLE_BASES = [ AccessPointDriver, + BackupServerDriver, FirewallDriver, HypervisorDriver, ManagementControllerDriver, @@ -75,6 +77,8 @@ class TestDeclaredMethodsDoNotExistAtRuntime: @pytest.mark.parametrize( ("base", "method"), [ + (BackupServerDriver, "get_backup_datastores"), + (BackupServerDriver, "run_backup_job"), (StorageDriver, "get_disks"), (StorageDriver, "get_volumes"), (HypervisorDriver, "get_vms"), diff --git a/tests/test_type_label.py b/tests/test_type_label.py index c215788..22418dc 100644 --- a/tests/test_type_label.py +++ b/tests/test_type_label.py @@ -4,6 +4,7 @@ import pytest from napalm_device_types import ( AccessPointDriver, + BackupServerDriver, FirewallDriver, HypervisorDriver, ManagementControllerDriver, @@ -15,6 +16,7 @@ from napalm_device_types import ( BASE_CLASSES = [ (AccessPointDriver, "Access Point"), + (BackupServerDriver, "Backup Server"), (FirewallDriver, "Firewall"), (HypervisorDriver, "Hypervisor"), (ManagementControllerDriver, "Management Controller"),