annet 0.16.33__tar.gz → 0.16.35__tar.gz

{annet-0.16.33/annet.egg-info → annet-0.16.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 0.16.33
+Version: 0.16.35
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT
@@ -23,7 +23,7 @@ Requires-Dist: yarl>=1.8.2
 Requires-Dist: adaptix==3.0.0b7
 Requires-Dist: dataclass-rest==0.4
 Provides-Extra: netbox
-Requires-Dist: annetbox[sync]>=0.1.10; extra == "netbox"
+Requires-Dist: annetbox[sync]>=0.1.12; extra == "netbox"
 Dynamic: home-page
 Dynamic: license
 Dynamic: provides-extra

annet-0.16.35/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.33 → annet-0.16.35}/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,21 +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 []
-        if self.exact_host_filter:
-            devices = self.netbox.dcim_all_devices(name__ie=query.globs).results
-        else:
-            query = _hostname_dot_hack(query)
-            devices = [
-                device
-                for device in self.netbox.dcim_all_devices(
-                    name__ic=query.globs,
-                ).results
-                if _match_query(query, device)
-            ]
-        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 = {
@@ -227,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)
@@ -237,6 +278,7 @@ class NetboxStorageV37(Storage):
             interfaces=interfaces,
             neighbours=neighbours,
         )
+        self._record_device(res)
         return res
 
     def flush_perf(self):
@@ -261,14 +303,23 @@ 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:
+        if short_name == hostname or device_data.name == hostname:
             return True
     return False
 
 
-def _hostname_dot_hack(netbox_query: NetboxQuery) -> NetboxQuery:
+def _hostname_dot_hack(raw_query: str) -> str:
     # there is no proper way to lookup host by its hostname
     # ie find "host" with fqdn "host.example.com"
     # besides using name__ic (ie startswith)
@@ -280,9 +331,20 @@ def _hostname_dot_hack(netbox_query: NetboxQuery) -> NetboxQuery:
             raw_query = raw_query + "."
         return raw_query
 
-    raw_query = netbox_query.query
     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 NetboxQuery(raw_query)
+    return raw_query
+
+
+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"] = [_hostname_dot_hack(name) for name in names]
+    return query_groups

{annet-0.16.33 → annet-0.16.35}/annet/annlib/netdev/devdb/data/devdb.json

@@ -166,6 +166,8 @@
 
     "B4com": "^[Bb]4com",
     "B4com.CS2148P": "^[Bb]4com B4T-CS2148P.*",
+    "B4com.CS4100": "^[Bb]4com B4T-CS41.*",
+    "B4com.CS4132U": "^[Bb]4com B4T-CS4132U.*",
     "B4com.CS4148Q": "^[Bb]4com B4T-CS4148Q.*",
-    "B4com.CS4146U": "^[Bb]4com B4T-CS4146U.*"
+    "B4com.CS4164U": "^[Bb]4com B4T-CS4164U.*"
 }

{annet-0.16.33 → annet-0.16.35}/annet/annlib/rulebook/common.py

@@ -346,14 +346,14 @@ def apply(hw, do_commit, do_finalize, **_):
         after.add_cmd(Command("exit"))
     elif hw.B4com.CS2148P:
         before.add_cmd(Command("conf t"))
-        after.add_cmd(Command("exit"))
+        after.add_cmd(Command("end"))
         if do_finalize:
             after.add_cmd(Command("write", timeout=40))
     elif hw.B4com:
         before.add_cmd(Command("conf t"))
-        after.add_cmd(Command("exit"))
         if do_commit:
             after.add_cmd(Command("commit"))
+            after.add_cmd(Command("end"))
         if do_finalize:
             after.add_cmd(Command("write", timeout=40))
     elif hw.H3C:

{annet-0.16.33 → annet-0.16.35}/annet/bgp_models.py

@@ -142,7 +142,6 @@ class Peer:
 class Aggregate:
     policy: str = ""
     routes: tuple[str, ...] = ()  # "182.168.1.0/24",
-    export_policy: str = ""
     as_path: str = ""
     reference: str = ""
     suppress: bool = False
@@ -290,21 +289,18 @@ def _used_policies(peer: Union[Peer, PeerGroup]) -> Iterable[str]:
 
 
 def _used_redistribute_policies(opts: Union[GlobalOptions, VrfOptions]) -> Iterable[str]:
-    for red in opts.ipv4_unicast.redistributes:
-        if red.policy:
-            yield red.policy
-    for red in opts.ipv6_unicast.redistributes:
-        if red.policy:
-            yield red.policy
-    for red in opts.ipv4_labeled_unicast.redistributes:
-        if red.policy:
-            yield red.policy
-    for red in opts.ipv6_labeled_unicast.redistributes:
-        if red.policy:
-            yield red.policy
-    for red in opts.l2vpn_evpn.redistributes:
-        if red.policy:
-            yield red.policy
+    for family_opts in (
+        opts.ipv4_unicast,
+        opts.ipv6_unicast,
+        opts.ipv4_labeled_unicast,
+        opts.ipv6_labeled_unicast,
+        opts.l2vpn_evpn,
+    ):
+        for red in family_opts.redistributes:
+            if red.policy:
+                yield red.policy
+        if family_opts.aggregate and family_opts.aggregate.policy:
+            yield family_opts.aggregate.policy
 
 
 def extract_policies(config: BgpConfig) -> Sequence[str]:

{annet-0.16.33 → annet-0.16.35}/annet/mesh/device_models.py

@@ -8,7 +8,6 @@ from .peer_models import MeshPeerGroup
 class Aggregate(BaseMeshModel):
     policy: str
     routes: Annotated[tuple[str, ...], Concat()]
-    export_policy: str
     as_path: str
     reference: str
     suppress: bool
@@ -22,7 +21,7 @@ class FamilyOptions(BaseMeshModel):
         super().__init__(**kwargs)
     family: Family
     vrf_name: str
-    multipath: int = 0
+    multipath: int
     global_multipath: int
     aggregate: Annotated[Aggregate, Merge()]
     redistributes: Annotated[tuple[Redistribute, ...], Concat()]

{annet-0.16.33 → annet-0.16.35}/annet/mesh/executor.py

@@ -144,8 +144,17 @@ class MeshExecutor:
         for rule in rules:
             handler_name = self._handler_name(rule.handler)
             if rule.direct_order:
+                if rule.name_right not in neigbors:
+                    print(list(neigbors), flush=True)
+                    raise ValueError(
+                        f"Device `{device.fqdn}` has no neighbor `{rule.name_right}` required for `{handler_name}`. {list(neigbors)}",
+                    )
                 neighbor_device = neigbors[rule.name_right]
             else:
+                if rule.name_left not in neigbors:
+                    raise ValueError(
+                        f"Device `{device.fqdn}` has no neighbor `{rule.name_left}` required for `{handler_name}`",
+                    )
                 neighbor_device = neigbors[rule.name_left]
             all_connected_ports = [
                 (p1.name, p2.name)

{annet-0.16.33 → annet-0.16.35}/annet/mesh/registry.py

@@ -208,11 +208,11 @@ class MeshRulesRegistry:
 
     def lookup_direct(self, device: str, neighbors: list[str]) -> list[MatchedDirectPair]:
         found = []
-        device = self._normalize_host(device)
+        device_norm = self._normalize_host(device)
         for neighbor in neighbors:
-            neighbor = self._normalize_host(neighbor)
+            neighbor_norm = self._normalize_host(neighbor)
             for rule in self.direct_rules:
-                if args := rule.matcher.match_pair(device, neighbor):
+                if args := rule.matcher.match_pair(device_norm, neighbor_norm):
                     found.append(MatchedDirectPair(
                         handler=rule.handler,
                         port_processor=rule.port_processor,
@@ -222,7 +222,7 @@ class MeshRulesRegistry:
                         match_left=args[0],
                         match_right=args[1],
                     ))
-                if args := rule.matcher.match_pair(neighbor, device):
+                if args := rule.matcher.match_pair(neighbor_norm, device_norm):
                     found.append(MatchedDirectPair(
                         handler=rule.handler,
                         port_processor=rule.port_processor,
@@ -238,11 +238,11 @@ class MeshRulesRegistry:
 
     def lookup_indirect(self, device: str, devices: list[str]) -> list[MatchedIndirectPair]:
         found = []
-        device = self._normalize_host(device)
+        device_norm = self._normalize_host(device)
         for other_device in devices:
-            other_device = self._normalize_host(other_device)
+            other_device_norm = self._normalize_host(other_device)
             for rule in self.indirect_rules:
-                if args := rule.matcher.match_pair(device, other_device):
+                if args := rule.matcher.match_pair(device_norm, other_device_norm):
                     found.append(MatchedIndirectPair(
                         handler=rule.handler,
                         direct_order=True,
@@ -251,7 +251,7 @@ class MeshRulesRegistry:
                         match_left=args[0],
                         match_right=args[1],
                     ))
-                if args := rule.matcher.match_pair(other_device, device):
+                if args := rule.matcher.match_pair(other_device_norm, device_norm):
                     found.append(MatchedIndirectPair(
                         handler=rule.handler,
                         direct_order=False,
@@ -266,9 +266,9 @@ class MeshRulesRegistry:
 
     def lookup_virtual(self, device: str) -> list[MatchedVirtualPair]:
         found = []
-        device = self._normalize_host(device)
+        device_norm = self._normalize_host(device)
         for rule in self.virtual_rules:
-            if args := rule.matcher.match_one(device):
+            if args := rule.matcher.match_one(device_norm):
                 found.append(MatchedVirtualPair(
                     handler=rule.handler,
                     match=args,
@@ -280,9 +280,9 @@ class MeshRulesRegistry:
 
     def lookup_global(self, device: str) -> list[MatchedGlobal]:
         found = []
-        device = self._normalize_host(device)
+        device_norm = self._normalize_host(device)
         for rule in self.global_rules:
-            if args := rule.matcher.match_one(device):
+            if args := rule.matcher.match_one(device_norm):
                 found.append(MatchedGlobal(
                     handler=rule.handler,
                     match=args,

annet-0.16.35/annet/rulebook/b4com/iface.py

@@ -0,0 +1,42 @@
+from annet.annlib.types import Op
+
+from annet.rulebook import common
+
+
+def mtu(rule, key, diff, **kwargs):
+    """
+    Удаляем mtu без указания значения
+    """
+    if diff[Op.REMOVED]:
+        yield (False, "no mtu", None)
+    elif diff[Op.ADDED]:
+        yield from common.default(rule, key, diff, **kwargs)
+
+
+def sflow(rule, key, diff, **kwargs):
+    """
+    Команда sflow sampling-rate * direction ingress max-header-size *
+    сносится без указания sampling-rate и max-header-size
+    """
+    result = common.default(rule, key, diff, **kwargs)
+    for op, cmd, ch in result:
+        if diff[Op.REMOVED]:
+            if "ingress" in diff[Op.REMOVED][0]["row"]:
+                yield (op, "no sflow sampling-rate direction ingress", ch)
+            elif "egress" in diff[Op.REMOVED][0]["row"]:
+                yield (op, "no sflow sampling-rate direction egress", ch)
+            else:
+                yield (op, cmd, ch)
+    return result
+
+
+def lldp(rule, key, diff, **kwargs):
+    """
+    Не удаляем все что начинается с set, т.к. set перезаписывает предыдущий конфиг
+    """
+    result = common.default(rule, key, diff, **kwargs)
+    for op, cmd, ch in result:
+        if diff[Op.REMOVED] and "set lldp" in cmd:
+            pass
+        else:
+            yield (op, cmd, ch)

{annet-0.16.33 → annet-0.16.35}/annet/rulebook/texts/b4com.rul

@@ -1,6 +1,6 @@
 # Операторы:
-#   *  Один аргумент в undo
-#   ~  Несколько аргументов (минимум один) в undo
+#   *  Один аргумент в no
+#   ~  Несколько аргументов (минимум один) в no
 #
 # Параметры:
 #   %global         Команда действует на любом уровне ниже
@@ -11,8 +11,13 @@
 #                   Сделано в основном для того чтобы генерировать специальные команды для наливки
 # -----
 # Physical
+sflow *
+
 interface */(ce|xe)[0-9\/]+$/     %logic=common.permanent %diff_logic=cisco.iface.diff
     ipv6 address *
-    mtu *
+    mtu *                         %logic=b4com.iface.mtu
+    sflow *                       %logic=b4com.iface.sflow
     lldp-agent
-    ~         %rewrite %global
+        ~ %global                 %logic=b4com.iface.lldp
+        !dcbx *
+        !exit

{annet-0.16.33 → annet-0.16.35}/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.33 → annet-0.16.35/annet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 0.16.33
+Version: 0.16.35
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT
@@ -23,7 +23,7 @@ Requires-Dist: yarl>=1.8.2
 Requires-Dist: adaptix==3.0.0b7
 Requires-Dist: dataclass-rest==0.4
 Provides-Extra: netbox
-Requires-Dist: annetbox[sync]>=0.1.10; extra == "netbox"
+Requires-Dist: annetbox[sync]>=0.1.12; extra == "netbox"
 Dynamic: home-page
 Dynamic: license
 Dynamic: provides-extra

{annet-0.16.33 → annet-0.16.35}/annet.egg-info/SOURCES.txt

@@ -130,6 +130,7 @@ annet/rulebook/aruba/ap_env.py
 annet/rulebook/aruba/misc.py
 annet/rulebook/b4com/__init__.py
 annet/rulebook/b4com/file.py
+annet/rulebook/b4com/iface.py
 annet/rulebook/cisco/__init__.py
 annet/rulebook/cisco/iface.py
 annet/rulebook/cisco/misc.py

{annet-0.16.33 → annet-0.16.35}/annet.egg-info/requires.txt

@@ -15,4 +15,4 @@ adaptix==3.0.0b7
 dataclass-rest==0.4
 
 [netbox]
-annetbox[sync]>=0.1.10
+annetbox[sync]>=0.1.12

{annet-0.16.33 → annet-0.16.35}/setup.py

@@ -44,7 +44,7 @@ if __name__ == "__main__":
           ],
         },
         extras_require={
-            "netbox": ["annetbox[sync]>=0.1.10"],
+            "netbox": ["annetbox[sync]>=0.1.12"],
         },
         python_requires=">=3.10",
         install_requires=requirements(),

annet-0.16.33/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