annet 0.16.34__tar.gz → 0.16.36__tar.gz

{annet-0.16.34/annet.egg-info → annet-0.16.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 0.16.34
+Version: 0.16.36
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-0.16.34 → annet-0.16.36}/annet/adapters/netbox/common/manufacturer.py

@@ -54,7 +54,7 @@ def get_breed(manufacturer: str, model: str):
         return "bcom-os"
     elif manufacturer == "MikroTik":
         return "routeros"
-    elif manufacturer == "Moxa":
+    elif manufacturer in ("Moxa", "Nebius"):
         return "moxa"
     elif manufacturer == "PC":
         return "pc"

{annet-0.16.34 → annet-0.16.36}/annet/adapters/netbox/common/models.py

@@ -214,7 +214,8 @@ class NetboxDevice(Entity):
         return type(self) is type(other) and self.url == other.url
 
     def is_pc(self) -> bool:
-        return self.device_type.manufacturer.name in ("Mellanox", "NVIDIA", "Moxa") or self.breed == "pc"
+        custom_breed_pc = ("Mellanox", "NVIDIA", "Moxa", "Nebius")
+        return self.device_type.manufacturer.name in custom_breed_pc or self.breed == "pc"
 
     def _make_interface(self, name: str, type: InterfaceType) -> Interface:
         return Interface(

annet-0.16.36/annet/adapters/netbox/common/query.py

@@ -0,0 +1,61 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import cast, List, Union, Iterable, Optional, TypedDict
+
+from annet.storage import Query
+
+FIELD_VALUE_SEPARATOR = ":"
+ALLOWED_GLOB_GROUPS = ["site", "tag", "role"]
+
+
+class Filter(TypedDict, total=False):
+    site: list[str]
+    tag: list[str]
+    role: list[str]
+    name: list[str]
+
+
+@dataclass
+class NetboxQuery(Query):
+    query: List[str]
+
+    @classmethod
+    def new(
+            cls, query: Union[str, Iterable[str]],
+            hosts_range: Optional[slice] = None,
+    ) -> "NetboxQuery":
+        if hosts_range is not None:
+            raise ValueError("host_range is not supported")
+        return cls(query=list(query))
+
+    @property
+    def globs(self):
+        # We process every query host as a glob
+        return self.query
+
+    def parse_query(self) -> Filter:
+        query_groups = defaultdict(list)
+        for q in self.globs:
+            if FIELD_VALUE_SEPARATOR in q:
+                glob_type, param = q.split(FIELD_VALUE_SEPARATOR, 2)
+                if glob_type not in ALLOWED_GLOB_GROUPS:
+                    raise Exception(f"unknown query type: '{glob_type}'")
+                if not param:
+                    raise Exception(f"empty param for '{glob_type}'")
+                query_groups[glob_type].append(param)
+            else:
+                query_groups["name"].append(q)
+
+        query_groups.default_factory = None
+        return cast(Filter, query_groups)
+
+    def is_empty(self) -> bool:
+        return len(self.query) == 0
+
+    def is_host_query(self) -> bool:
+        if not self.globs:
+            return False
+        for q in self.globs:
+            if FIELD_VALUE_SEPARATOR in q:
+                return False
+        return True

{annet-0.16.34 → annet-0.16.36}/annet/adapters/netbox/v37/storage.py

@@ -1,8 +1,8 @@
-from logging import getLogger
-from typing import Any, Optional, List, Union, Dict
-from ipaddress import ip_interface
-from collections import defaultdict
 import ssl
+from collections import defaultdict
+from ipaddress import ip_interface
+from logging import getLogger
+from typing import Any, Optional, List, Union, Dict, cast
 
 from adaptix import P
 from adaptix.conversion import impl_converter, link, link_constant
@@ -13,7 +13,7 @@ from annet.adapters.netbox.common import models
 from annet.adapters.netbox.common.manufacturer import (
     get_hw, get_breed,
 )
-from annet.adapters.netbox.common.query import NetboxQuery
+from annet.adapters.netbox.common.query import NetboxQuery, FIELD_VALUE_SEPARATOR
 from annet.adapters.netbox.common.storage_opts import NetboxStorageOpts
 from annet.annlib.netdev.views.hardware import HardwareView
 from annet.storage import Storage, Device, Interface
@@ -101,6 +101,9 @@ class NetboxStorageV37(Storage):
             self.exact_host_filter = opts.exact_host_filter
         self.netbox = NetboxV37(url=url, token=token, ssl_context=ctx)
         self._all_fqdns: Optional[list[str]] = None
+        self._id_devices: dict[int, models.NetboxDevice] = {}
+        self._name_devices: dict[str, models.NetboxDevice] = {}
+        self._short_name_devices: dict[str, models.NetboxDevice] = {}
 
     def __enter__(self):
         return self
@@ -136,6 +139,37 @@ class NetboxStorageV37(Storage):
     ) -> List[models.NetboxDevice]:
         if isinstance(query, list):
             query = NetboxQuery.new(query)
+
+        devices = []
+        if query.is_host_query():
+            globs = []
+            for glob in query.globs:
+                if glob in self._name_devices:
+                    devices.append(self._name_devices[glob])
+                if glob in self._short_name_devices:
+                    devices.append(self._short_name_devices[glob])
+                else:
+                    globs.append(glob)
+            if not globs:
+                return devices
+            query = NetboxQuery.new(globs)
+
+        return devices + self._make_devices(
+            query=query,
+            preload_neighbors=preload_neighbors,
+            use_mesh=use_mesh,
+            preload_extra_fields=preload_extra_fields,
+            **kwargs
+        )
+
+    def _make_devices(
+            self,
+            query: NetboxQuery,
+            preload_neighbors=False,
+            use_mesh=None,
+            preload_extra_fields=False,
+            **kwargs,
+    ) -> List[models.NetboxDevice]:
         device_ids = {
             device.id: extend_device(
                 device=device,
@@ -148,6 +182,9 @@ class NetboxStorageV37(Storage):
         if not device_ids:
             return []
 
+        for device in device_ids.values():
+            self._record_device(device)
+
         interfaces = self._load_interfaces(list(device_ids))
         neighbours = {x.id: x for x in self._load_neighbours(interfaces)}
         neighbours_seen: dict[str, set] = defaultdict(set)
@@ -162,32 +199,22 @@ class NetboxStorageV37(Storage):
 
         return list(device_ids.values())
 
+    def _record_device(self, device: models.NetboxDevice):
+        self._id_devices[device.id] = device
+        self._short_name_devices[device.name] = device
+        if not self.exact_host_filter:
+            short_name = device.name.split(".")[0]
+            self._short_name_devices[short_name] = device
+
     def _load_devices(self, query: NetboxQuery) -> List[api_models.Device]:
         if not query.globs:
             return []
-        devices = []
-        device_ids = set()
-        query_groups = parse_glob(query.globs)
-        if self.exact_host_filter:
-            name_ies = [_hostname_dot_hack(query) for query in query_groups.pop("name__ic", [])]
-            query_groups["name__ie"].extend(name_ies)
-        for grp, params in query_groups.items():
-            if not params:
-                continue
-            try:
-                new_devices = self.netbox.dcim_all_devices(**{grp: params}).results
-            except Exception as e:
-                # tag and site lookup returns 400 in case of unknown tag or site
-                if "is not one of the available choices" in str(e):
-                    continue
-                raise
-            if grp == "name__ic":
-                new_devices = [device for device in new_devices if _match_query(query, device)]
-            for device in new_devices:
-                if device.id not in device_ids:
-                    device_ids.add(device.id)
-                    devices.extend(new_devices)
-        return devices
+        query_groups = parse_glob(self.exact_host_filter, query)
+        return [
+            device
+            for device in self.netbox.dcim_all_devices(**query_groups).results
+            if _match_query(self.exact_host_filter, query, device)
+        ]
 
     def _extend_interfaces(self, interfaces: List[models.Interface]) -> List[models.Interface]:
         extended_ifaces = {
@@ -238,6 +265,9 @@ class NetboxStorageV37(Storage):
             self, obj_id, preload_neighbors=False, use_mesh=None,
             **kwargs,
     ) -> models.NetboxDevice:
+        if obj_id in self._id_devices:
+            return self._id_devices[obj_id]
+
         device = self.netbox.dcim_device(obj_id)
         interfaces = self._load_interfaces([device.id])
         neighbours = self._load_neighbours(interfaces)
@@ -248,6 +278,7 @@ class NetboxStorageV37(Storage):
             interfaces=interfaces,
             neighbours=neighbours,
         )
+        self._record_device(res)
         return res
 
     def flush_perf(self):
@@ -272,9 +303,20 @@ class NetboxStorageV37(Storage):
         return res
 
 
-def _match_query(query: NetboxQuery, device_data: api_models.Device) -> bool:
-    for subquery in query.globs:
-        if subquery.strip() in device_data.name:
+def _match_query(exact_host_filter: bool, query: NetboxQuery, device_data: api_models.Device) -> bool:
+    """
+    Additional filtering after netbox due to limited backend logic.
+    """
+    if exact_host_filter:
+        return True  # nothing to check, all filtering is done by netbox
+    hostnames = [subquery.strip() for subquery in query.globs if FIELD_VALUE_SEPARATOR not in subquery]
+    if not hostnames:
+        return True  # no hostnames to check
+
+    short_name = device_data.name.split(".")[0]
+    for hostname in hostnames:
+        hostname = hostname.strip().rstrip(".")
+        if short_name == hostname or device_data.name == hostname:
             return True
     return False
 
@@ -294,20 +336,17 @@ def _hostname_dot_hack(raw_query: str) -> str:
     if isinstance(raw_query, list):
         for i, name in enumerate(raw_query):
             raw_query[i] = add_dot(name)
+    elif isinstance(raw_query, str):
+        raw_query = add_dot(raw_query)
 
     return raw_query
 
 
-def parse_glob(globs: list[str]) -> dict[str, list[str]]:
-    query_groups: dict[str, list[str]] = {"tag": [], "site": [], "name__ic": []}
-    for q in globs:
-        if ":" in q:
-            glob_type, param = q.split(":", 2)
-            if glob_type not in query_groups:
-                raise Exception(f"unknown query type: '{glob_type}'")
-            if not param:
-                raise Exception(f"empty param for '{glob_type}'")
-            query_groups[glob_type].append(param)
+def parse_glob(exact_host_filter: bool, query: NetboxQuery) -> dict[str, list[str]]:
+    query_groups = cast(dict[str, list[str]], query.parse_query())
+    if names := query_groups.pop("name", None):
+        if exact_host_filter:
+            query_groups["name__ie"] = names
         else:
-            query_groups["name__ic"].append(q)
+            query_groups["name__ic"] = [_hostname_dot_hack(name) for name in names]
     return query_groups

{annet-0.16.34 → annet-0.16.36}/annet/annlib/netdev/devdb/data/devdb.json

@@ -104,7 +104,7 @@
     "Nokia.NS7750": " 7750",
     "Nokia.SR_1s": "SR-1s",
 
-    "PC": "^(PC|pc|[Mm]ellanox SN|[Ee]dge-?[Cc]ore|[Mm]oxa|NVIDIA|[Aa]sterfusion CX|[Uu]fi[Ss]pace)",
+    "PC": "^(PC|pc|[Mm]ellanox SN|[Ee]dge-?[Cc]ore|[Mm]oxa|NVIDIA|Nebius|[Aa]sterfusion CX|[Uu]fi[Ss]pace)",
 
     "PC.Whitebox": "([Mm]ellanox SN|[Ee]dge-?[Cc]ore|NVIDIA|[Aa]sterfusion CX|[Uu]fi[Ss]pace)",
     "PC.Whitebox.Mellanox": "[Mm]ellanox",
@@ -132,6 +132,8 @@
     "PC.Whitebox.Ufispace.S": " S",
     "PC.Whitebox.Ufispace.S.S9100": " S91\\d\\d",
     "PC.Whitebox.Ufispace.S.S9100.S9110_32X": " S9110-32X",
+    "PC.Nebius": "^Nebius",
+    "PC.Nebius.NB-E-BR-DCU-AST2600": "^Nebius NB-E-BR-DCU-AST2600",
 
     "RouterOS": "^([Rr]outer[Oo][Ss]|[Mm]ikro[Tt]ik)",
 

{annet-0.16.34 → annet-0.16.36}/annet/bgp_models.py

@@ -245,8 +245,10 @@ class VrfOptions:
     l2vpn_evpn: FamilyOptions
 
     vrf_name_global: Optional[str] = None
-    l3vni: Optional[int] = None
+    import_policy: str = ""
+    export_policy: str = ""
     as_path_relax: bool = False
+    l3vni: Optional[int] = None
     rt_import: list[str] = field(default_factory=list)
     rt_export: list[str] = field(default_factory=list)
     rt_import_v4: list[str] = field(default_factory=list)
@@ -281,7 +283,7 @@ class BgpConfig:
     peers: list[Peer]
 
 
-def _used_policies(peer: Union[Peer, PeerGroup]) -> Iterable[str]:
+def _used_policies(peer: Union[Peer, PeerGroup, VrfOptions]) -> Iterable[str]:
     if peer.import_policy:
         yield peer.import_policy
     if peer.export_policy:
@@ -309,6 +311,7 @@ def extract_policies(config: BgpConfig) -> Sequence[str]:
         for group in vrf.groups:
             result.extend(_used_policies(group))
         result.extend(_used_redistribute_policies(vrf))
+        result.extend(_used_policies(vrf))
     for group in config.global_options.groups:
         result.extend(_used_policies(group))
     for peer in config.peers:

{annet-0.16.34 → annet-0.16.36}/annet/rpl_generators/prefix_lists.py

@@ -128,8 +128,7 @@ class PrefixListFilterGenerator(PartialGenerator, ABC):
                 name,
                 f"seq {i * 5 + 5}",
                 "permit",
-                str(addr_mask.ip).upper(),
-                str(addr_mask.network.prefixlen),
+                addr_mask.with_prefixlen,
             ) + (
                 ("ge", str(match.greater_equal)) if match.greater_equal is not None else ()
             ) + (

{annet-0.16.34 → annet-0.16.36}/annet/rulebook/texts/arista.order

@@ -88,6 +88,7 @@ interface
 
 (?:ip|ipv6) routing
 
+ip prefix-list
 
 ip community-list
 

{annet-0.16.34 → annet-0.16.36}/annet/rulebook/texts/huawei.deploy

@@ -32,7 +32,7 @@ undo route-distinguisher *
     dialog: Warning: All VPN targets of this EVPN instance and all EVPN address family-related configurations under BGP will be deleted. Continue? [Y/N]: ::: Y
 
 save
-    dialog: Warning: The current configuration will be written to the device. Continue? [Y/N] ::: Y
+    dialog: /Warning: The current configuration will be written to the device. Continue\? \[Y/N\]:?/ ::: Y
     dialog: Warning: The current configuration will be written to the device. Are you sure to continue? [Y/N]: ::: Y
     dialog: Are you sure to continue?[Y/N] ::: Y
     dialog: Are you sure to continue? [Y/N] ::: Y

{annet-0.16.34 → annet-0.16.36/annet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 0.16.34
+Version: 0.16.36
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

annet-0.16.34/annet/adapters/netbox/common/query.py

@@ -1,26 +0,0 @@
-from dataclasses import dataclass
-from typing import List, Union, Iterable, Optional
-
-from annet.storage import Query
-
-
-@dataclass
-class NetboxQuery(Query):
-    query: List[str]
-
-    @classmethod
-    def new(
-            cls, query: Union[str, Iterable[str]],
-            hosts_range: Optional[slice] = None,
-    ) -> "NetboxQuery":
-        if hosts_range is not None:
-            raise ValueError("host_range is not supported")
-        return cls(query=list(query))
-
-    @property
-    def globs(self):
-        # We process every query host as a glob
-        return self.query
-
-    def is_empty(self) -> bool:
-        return len(self.query) == 0