feat(backup): BackupServerDriver, a role base for backup servers (#82) #83

Merged
christianmanivong merged 1 commits from feat/backup-server-role into main 2026-11-02 19:55:05 +00:00
12 changed files with 668 additions and 3 deletions

No files matched your search

+13
View File
@@ -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
+13
View File
@@ -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
+1 -1
View File
@@ -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` |
+31
View File
@@ -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",
+238
View File
@@ -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.
"""
...
+119
View File
@@ -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
+5
View File
@@ -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):
+234
View File
@@ -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",
}
+6 -1
View File
@@ -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)
+2 -1
View File
@@ -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
+4
View File
@@ -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"),
+2
View File
@@ -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"),