diff --git a/CHANGELOG.md b/CHANGELOG.md index a52306f..50d1cc8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,12 @@ recorded here; their history is the git log. 3.12 venv no longer has. ### Added +- `NetworkTargetDict.uplinks` (optional): the physical NICs a bridge leaves the + host through, one group per way out -- a bond's slaves together, a single NIC + alone (`[["eno1", "eno2"]]`). A missing key means unknown, an empty list a + bridge without uplink. NetOrk follows their LLDP neighbours to the switch port + and its untagged VLAN; one slave's neighbour speaks for its bond + (NetOrk/netork#1325). - `HostShutdownMixin.shutdown_host()`, on `DeviceTypeDriver`: shut the device itself down cleanly through its own means; declared, so `hasattr` says whether a driver can. No forced variant (NetOrk/netork#1636). diff --git a/README.md b/README.md index a206e3f..cf369a6 100644 --- a/README.md +++ b/README.md @@ -503,6 +503,14 @@ class ProxmoxDriver(HypervisorDriver): def create_vm_snapshot(self, name, snapshot, description="", include_memory=False): ... + def get_network_targets(self): + # return List[NetworkTargetDict]: bridges and vnets a new VM's NIC may + # attach to; a bridge may name its physical NICs in `uplinks`, one group + # per way out: [["eno1", "eno2"]] for a bond, [["eno1"]] for a single NIC, + # no internal or VLAN ports -- leave the key out when they cannot be + # determined + ... + def get_vm_cpu_types(self): # optional — return List[VMCpuTypeDict]: the CPU models a new VM may get # on this node, each with its cpuinfo flags and whether the node can run diff --git a/napalm_device_types/hypervisor.py b/napalm_device_types/hypervisor.py index 5406f1d..86c3d42 100644 --- a/napalm_device_types/hypervisor.py +++ b/napalm_device_types/hypervisor.py @@ -613,7 +613,9 @@ class HypervisorDriver(PackageManagementMixin, HealthMetricsMixin, DeviceTypeDri List[NetworkTargetDict] - each entry's ``vlan_aware`` flag tells the caller whether a ``NICConfigDict.vlan_tag`` may additionally be set for a NIC using that target (see ``NetworkTargetDict`` for the - per-kind rules). + per-kind rules). ``uplinks``, where the driver can tell, names + the physical NICs a bridge leaves the host through, grouped: + a bond's slaves in one group, a single NIC in its own. """ ... diff --git a/napalm_device_types/models.py b/napalm_device_types/models.py index 9dbb158..112a57c 100644 --- a/napalm_device_types/models.py +++ b/napalm_device_types/models.py @@ -1310,17 +1310,17 @@ class NetworkTargetDict(TypedDict): Distinguishes real bridges (Linux or OVS) from SDN network segments (vnets), and tells the caller whether a separate ``vlan_tag`` may be applied on top: - Linux bridge: vlan_aware reflects the bridge's own ``bridge_vlan_aware`` flag. - - OVS bridge: always vlan_aware (OVS bridges tag per-port regardless of a - dedicated "VLAN aware" setting). - - SDN vnet: never vlan_aware — the VLAN is already fixed by the vnet's zone/tag, - so a NIC attached to it must not also carry a ``vlan_tag``. That fixed VLAN - is surfaced via ``fixed_vlan_tag`` instead, for display purposes. + - OVS bridge: always vlan_aware (OVS tags per port, with no "VLAN aware" setting). + - SDN vnet: never vlan_aware — its zone/tag fixes the VLAN (``fixed_vlan_tag``). + ``uplinks``: the physical NICs it leaves the host through, one group per way out + (a bond's slaves together, a single NIC alone); no internal, VLAN or virtual ports. """ name: str # Bridge, vnet or port group name, usable directly as NICConfigDict.bridge kind: str # "bridge", "vnet" or "portgroup" (VMware: VLAN fixed like a vnet's) vlan_aware: bool # True if a NICConfigDict.vlan_tag may be set on top of this target fixed_vlan_tag: NotRequired[int | None] # vnet only: the VLAN ID already baked into it + uplinks: NotRequired[list[list[str]]] # NIC groups it leaves through; absent = unknown class StorageTargetDict(TypedDict): diff --git a/tests/test_network_target_uplinks.py b/tests/test_network_target_uplinks.py new file mode 100644 index 0000000..bfc045b --- /dev/null +++ b/tests/test_network_target_uplinks.py @@ -0,0 +1,25 @@ +"""A network target can say which physical NICs it leaves the host through. + +A VM on a VLAN-aware bridge without a VLAN tag only gets an address when the +switch port behind the bridge carries an untagged network. To look that port up, +the caller needs the bridge's physical NICs: their LLDP neighbours name the +switch and the port (NetOrk/netork#1325). They come in groups, one per way out +of the bridge: a bond's slaves together, a single NIC alone. A bond has no +neighbour of its own, and its slaves are one link, so one slave's neighbour +speaks for the others when they report none. +""" + +from __future__ import annotations + +from typing import get_type_hints + +from napalm_device_types.models import NetworkTargetDict + + +def test_uplinks_is_an_optional_list_of_nic_groups(): + assert "uplinks" in NetworkTargetDict.__optional_keys__ + assert get_type_hints(NetworkTargetDict)["uplinks"] == list[list[str]] + + +def test_contract_core_stays_required(): + assert {"name", "kind", "vlan_aware"} <= NetworkTargetDict.__required_keys__