annet 0.16.30__tar.gz → 0.16.32__tar.gz

{annet-0.16.30/annet.egg-info → annet-0.16.32}/PKG-INFO

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

{annet-0.16.30 → annet-0.16.32}/annet/adapters/netbox/common/manufacturer.py

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

{annet-0.16.30 → annet-0.16.32}/annet/adapters/netbox/common/models.py

@@ -214,7 +214,7 @@ 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 == "Mellanox" or self.breed == "pc"
+        return self.device_type.manufacturer.name in ("Mellanox", "NVIDIA", "Moxa") or self.breed == "pc"
 
     def _make_interface(self, name: str, type: InterfaceType) -> Interface:
         return Interface(

{annet-0.16.30 → annet-0.16.32}/annet/api/__init__.py

@@ -274,12 +274,14 @@ def patch(args: cli_args.ShowPatchOptions, loader: ann_gen.Loader):
 
 def _patch_worker(device_id, args: cli_args.ShowPatchOptions, stdin, loader: ann_gen.Loader, filterer: filtering.Filterer):
     for res, _, patch_tree in res_diff_patch(device_id, args, stdin, loader, filterer):
+        old_files = res.old_files
         new_files = res.get_new_files(args.acl_safe)
         new_json_fragment_files = res.get_new_file_fragments(args.acl_safe)
         if new_files:
             for path, (cfg_text, _cmds) in new_files.items():
                 label = res.device.hostname + os.sep + path
-                yield label, cfg_text, False
+                if old_files.get(path) != cfg_text:
+                    yield label, cfg_text, False
         elif res.old_json_fragment_files or new_json_fragment_files:
             for path, (new_json_cfg, _cmds) in new_json_fragment_files.items():
                 label = res.device.hostname + os.sep + path
@@ -468,6 +470,9 @@ class PCDeployerJob(DeployerJob):
         elif not new_files and not new_json_fragment_files:
             return
 
+        enable_reload = self.args.entire_reload is not cli_args.EntireReloadFlag.no
+        force_reload = self.args.entire_reload is cli_args.EntireReloadFlag.force
+
         upload_files: Dict[str, bytes] = {}
         reload_cmds: Dict[str, bytes] = {}
         generator_types: Dict[str, GeneratorType] = {}
@@ -483,18 +488,23 @@ class PCDeployerJob(DeployerJob):
                     old_text = jsontools.format_json(old_json_cfg)
                     new_text = jsontools.format_json(file_content_or_json_cfg)
                     diff_content = "\n".join(_diff_file(old_text, new_text))
-                if diff_content:
-                    self._has_diff = True
-                upload_files[file], reload_cmds[file] = file_content.encode(), cmds.encode()
-                generator_types[file] = generator_type
-                self.cmd_lines.append("= Deploy cmds %s/%s " % (device.hostname, file))
-                self.cmd_lines.extend([cmds, ""])
-                self.cmd_lines.append("= %s/%s " % (device.hostname, file))
-                self.cmd_lines.extend([file_content, ""])
-                self.diff_lines.append("= %s/%s " % (device.hostname, file))
-                self.diff_lines.extend([diff_content, ""])
-
-        if upload_files:
+
+                if diff_content or force_reload:
+                    self._has_diff |= True
+
+                    upload_files[file] = file_content.encode()
+                    generator_types[file] = generator_type
+                    self.cmd_lines.append("= %s/%s " % (device.hostname, file))
+                    self.cmd_lines.extend([file_content, ""])
+                    self.diff_lines.append("= %s/%s " % (device.hostname, file))
+                    self.diff_lines.extend([diff_content, ""])
+
+                    if enable_reload:
+                        reload_cmds[file] = cmds.encode()
+                        self.cmd_lines.append("= Deploy cmds %s/%s " % (device.hostname, file))
+                        self.cmd_lines.extend([cmds, ""])
+
+        if self._has_diff:
             self.deploy_cmds[device] = {
                 "files": upload_files,
                 "cmds": reload_cmds,
@@ -534,13 +544,12 @@ class Deployer:
         self._filterer = filtering.filterer_connector.get()
 
     def parse_result(self, job: DeployerJob, result: ann_gen.OldNewResult):
-        entire_reload = self.args.entire_reload
         logger = get_logger(job.device.hostname)
 
         job.parse_result(result)
         self.failed_configs.update(job.failed_configs)
 
-        if job.has_diff() or entire_reload is entire_reload.force:
+        if job.has_diff():
             self.cmd_lines.extend(job.cmd_lines)
             self.deploy_cmds.update(job.deploy_cmds)
             self.diffs.update(job.diffs)

{annet-0.16.30 → annet-0.16.32}/annet/bgp_models.py

@@ -68,7 +68,7 @@ class BFDTimers:
     multiplier: int = 4
 
 
-Family = Literal["ipv4_unicast", "ipv6_unicast", "ipv4_labeled_unicast", "ipv6_labeled_unicast"]
+Family = Literal["ipv4_unicast", "ipv6_unicast", "ipv4_labeled_unicast", "ipv6_labeled_unicast", "l2vpn_evpn"]
 
 
 @dataclass(frozen=True)
@@ -207,7 +207,7 @@ class PeerGroup:
     auth_key: bool = False
     add_path: bool = False
     multipath: bool = False
-    multihop: bool = False
+    multihop: Optional[int] = None
     multihop_no_nexthop_change: bool = False
     af_no_install: bool = False
     bfd: bool = False
@@ -243,8 +243,10 @@ class VrfOptions:
     ipv6_unicast: FamilyOptions
     ipv4_labeled_unicast: FamilyOptions
     ipv6_labeled_unicast: FamilyOptions
+    l2vpn_evpn: FamilyOptions
 
     vrf_name_global: Optional[str] = None
+    l3vni: Optional[int] = None
     as_path_relax: bool = False
     rt_import: list[str] = field(default_factory=list)
     rt_export: list[str] = field(default_factory=list)
@@ -262,6 +264,7 @@ class GlobalOptions:
     ipv6_unicast: FamilyOptions
     ipv4_labeled_unicast: FamilyOptions
     ipv6_labeled_unicast: FamilyOptions
+    l2vpn_evpn: FamilyOptions
 
     as_path_relax: bool = False
     local_as: ASN = ASN(None)
@@ -299,6 +302,9 @@ def _used_redistribute_policies(opts: Union[GlobalOptions, VrfOptions]) -> Itera
     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
 
 
 def extract_policies(config: BgpConfig) -> Sequence[str]:

{annet-0.16.30 → annet-0.16.32}/annet/mesh/basemodel.py

@@ -133,6 +133,9 @@ class BaseMeshModel:
             raise AttributeError(f"{self.__class__.__name__} has no field {key}")
         super().__setattr__(key, value)
 
+    def is_empty(self):
+        return not self.__dict__
+
 
 ModelT = TypeVar("ModelT", bound=BaseMeshModel)
 

{annet-0.16.30 → annet-0.16.32}/annet/mesh/device_models.py

@@ -43,11 +43,13 @@ class _FamiliesMixin:
         kwargs.setdefault("ipv6_unicast", FamilyOptions(family="ipv6_unicast"))
         kwargs.setdefault("ipv4_labeled_unicast", FamilyOptions(family="ipv4_labeled_unicast"))
         kwargs.setdefault("ipv6_labeled_unicast", FamilyOptions(family="ipv6_labeled_unicast"))
+        kwargs.setdefault("l2vpn_evpn", FamilyOptions(family="l2vpn_evpn"))
         super().__init__(**kwargs)
     ipv4_unicast: Annotated[FamilyOptions, Merge()]
     ipv6_unicast: Annotated[FamilyOptions, Merge()]
     ipv4_labeled_unicast: Annotated[FamilyOptions, Merge()]
     ipv6_labeled_unicast: Annotated[FamilyOptions, Merge()]
+    l2vpn_evpn: Annotated[FamilyOptions, Merge()]
 
 
 class VrfOptions(_FamiliesMixin, BaseMeshModel):
@@ -56,6 +58,7 @@ class VrfOptions(_FamiliesMixin, BaseMeshModel):
         kwargs.setdefault("ipv6_unicast", FamilyOptions(family="ipv6_unicast", vrf_name=vrf_name))
         kwargs.setdefault("ipv4_labeled_unicast", FamilyOptions(family="ipv4_labeled_unicast", vrf_name=vrf_name))
         kwargs.setdefault("ipv6_labeled_unicast", FamilyOptions(family="ipv6_labeled_unicast", vrf_name=vrf_name))
+        kwargs.setdefault("l2vpn_evpn", FamilyOptions(family="l2vpn_evpn", vrf_name=vrf_name))
         kwargs.setdefault("groups", KeyDefaultDict(lambda x: MeshPeerGroup(name=x)))
         super().__init__(vrf_name=vrf_name, **kwargs)
 
@@ -64,6 +67,7 @@ class VrfOptions(_FamiliesMixin, BaseMeshModel):
     as_path_relax: bool
     import_policy: Optional[str]
     export_policy: Optional[str]
+    l3vni: Optional[int]
     rt_import: Annotated[tuple[str, ...], Concat()]
     rt_export: Annotated[tuple[str, ...], Concat()]
     rt_import_v4: Annotated[tuple[str, ...], Concat()]

{annet-0.16.30 → annet-0.16.32}/annet/mesh/executor.py

@@ -57,6 +57,11 @@ class MeshExecutor:
             rule_global_opts = MeshGlobalOptions(rule.match, device)
             logger.debug("Running device handler: %s", handler_name)
             rule.handler(rule_global_opts)
+
+            if rule_global_opts.is_empty():
+                # nothing was set
+                continue
+
             try:
                 global_opts = merge(global_opts, rule_global_opts)
             except MergeForbiddenError as e:
@@ -79,7 +84,7 @@ class MeshExecutor:
             rule: MatchedDirectPair,
             ports: list[tuple[str, str]],
             all_connected_ports: list[tuple[str, str]],
-    ) -> Pair:
+    ) -> Optional[Pair]:
         session = MeshSession()
         handler_name = self._handler_name(rule.handler)
         logger.debug("Running direct handler: %s", handler_name)
@@ -102,6 +107,10 @@ class MeshExecutor:
         else:
             rule.handler(peer_neighbor, peer_device, session)
 
+        if peer_neighbor.is_empty() and peer_device.is_empty() and session.is_empty():
+            # nothing was set
+            return None
+
         try:
             neighbor_dto = merge(DirectPeerDTO(), peer_neighbor, session)
         except MergeForbiddenError as e:
@@ -144,6 +153,9 @@ class MeshExecutor:
             ]
             for ports in rule.port_processor(all_connected_ports):
                 pair = self._execute_direct_pair(device, neighbor_device, rule, ports, all_connected_ports)
+                if pair is None:
+                    # nothing was set
+                    continue
                 addr = getattr(pair.connected, "addr", None)
                 if addr is None:
                     raise ValueError(f"Handler `{handler_name}` returned no peer addr")
@@ -179,6 +191,9 @@ class MeshExecutor:
                 peer_virtual = VirtualPeer(num=order_number)
 
                 rule.handler(peer_device, peer_virtual, session)
+                if peer_virtual.is_empty() and peer_device.is_empty() and session.is_empty():
+                    # nothing was set
+                    continue
 
                 try:
                     virtual_dto = merge(VirtualPeerDTO(), peer_virtual, session)
@@ -232,6 +247,10 @@ class MeshExecutor:
                 peer_device = IndirectPeer(rule.match_right, device)
                 rule.handler(peer_connected, peer_device, session)
 
+            if peer_connected.is_empty() and peer_device.is_empty() and session.is_empty():
+                # nothing was set
+                continue
+
             try:
                 connected_dto = merge(IndirectPeerDTO(), peer_connected, session)
             except MergeForbiddenError as e:

{annet-0.16.30 → annet-0.16.32}/annet/mesh/peer_models.py

@@ -3,7 +3,7 @@ from typing import Literal, Annotated, Union, Optional
 from .basemodel import BaseMeshModel, Concat, Unite
 from ..bgp_models import BFDTimers
 
-FamilyName = Literal["ipv4_unicast", "ipv6_unicast", "ipv4_labeled_unicast", "ipv6_labeled_unicast"]
+FamilyName = Literal["ipv4_unicast", "ipv6_unicast", "ipv4_labeled_unicast", "ipv6_labeled_unicast", "l2vpn_evpn"]
 
 
 class _SharedOptionsDTO(BaseMeshModel):
@@ -53,7 +53,7 @@ class _OptionsDTO(_SharedOptionsDTO):
     advertise_bgp_static: bool
     allowas_in: bool
     auth_key: bool
-    multihop: bool
+    multihop: Optional[int]
     multihop_no_nexthop_change: bool
     af_no_install: bool
     rib: bool
@@ -101,7 +101,7 @@ class IndirectPeerDTO(MeshSession, _OptionsDTO):
 
 
 class VirtualLocalDTO(_OptionsDTO):
-    asnum: int
+    asnum: Union[int, str]
     pod: int
     addr: str
     description: str

{annet-0.16.30 → annet-0.16.32}/annet/mesh/registry.py

@@ -21,6 +21,9 @@ class DirectPeer(DirectPeerDTO):
         self.ports = ports
         self.all_connected_ports = all_connected_ports
 
+    def is_empty(self):
+        return self.__dict__.keys() == {"match", "device", "ports", "all_connected_ports"}
+
 
 class IndirectPeer(IndirectPeerDTO):
     match: MatchedArgs
@@ -31,6 +34,9 @@ class IndirectPeer(IndirectPeerDTO):
         self.match = match
         self.device = device
 
+    def is_empty(self):
+        return self.__dict__.keys() == {"match", "device"}
+
 
 class VirtualLocal(VirtualLocalDTO):
     match: MatchedArgs
@@ -41,10 +47,16 @@ class VirtualLocal(VirtualLocalDTO):
         self.match = match
         self.device = device
 
+    def is_empty(self):
+        return self.__dict__.keys() == {"match", "device"}
+
 
 class VirtualPeer(VirtualPeerDTO):
     num: int
 
+    def is_empty(self):
+        return self.__dict__.keys() == {"num"}
+
 
 class GlobalOptions(GlobalOptionsDTO):
     match: MatchedArgs
@@ -55,6 +67,9 @@ class GlobalOptions(GlobalOptionsDTO):
         self.match = match
         self.device = device
 
+    def is_empty(self):
+        return self.__dict__.keys() == {"match", "device"}
+
 
 GlobalHandler = Callable[[GlobalOptions], None]
 

{annet-0.16.30 → annet-0.16.32}/annet/rpl_generators/cumulus_frr.py

@@ -11,10 +11,10 @@ from annet.rpl.statement_builder import NextHopActionValue, AsPathActionValue, C
 from .aspath import get_used_as_path_filters
 from .community import get_used_united_community_lists
 from .entities import (
-    AsPathFilter, IpPrefixList, mangle_ranged_prefix_list_name, CommunityList, CommunityLogic, CommunityType,
-    mangle_united_community_list_name,
+    AsPathFilter, IpPrefixList, CommunityList, CommunityLogic, CommunityType,
+    mangle_united_community_list_name, PrefixListNameGenerator,
 )
-from .prefix_lists import get_used_prefix_lists
+from .prefix_lists import get_used_prefix_lists, new_prefix_list_name_generator
 
 FRR_RESULT_MAP = {
     ResultType.ALLOW: "permit",
@@ -51,6 +51,12 @@ class CumulusPolicyGenerator(ABC):
     def get_prefix_lists(self, device: Any) -> Sequence[IpPrefixList]:
         raise NotImplementedError()
 
+    def get_used_prefix_lists(self, device: Any, name_generator: PrefixListNameGenerator) -> Sequence[IpPrefixList]:
+        return get_used_prefix_lists(
+            prefix_lists=self.get_prefix_lists(device),
+            name_generator=name_generator,
+        )
+
     @abstractmethod
     def get_community_lists(self, device: Any) -> list[CommunityList]:
         raise NotImplementedError()
@@ -61,11 +67,13 @@ class CumulusPolicyGenerator(ABC):
 
     def generate_cumulus_rpl(self, device: Any) -> Iterator[Sequence[str]]:
         policies = self.get_policies(device)
+        prefix_list_name_generator = new_prefix_list_name_generator(policies)
+
         communities = {c.name: c for c in self.get_community_lists(device)}
         yield from self._cumulus_as_path_filters(device, policies)
         yield from self._cumulus_communities(device, communities, policies)
-        yield from self._cumulus_prefix_lists(device, policies)
-        yield from self._cumulus_policy_config(device, communities, policies)
+        yield from self._cumulus_prefix_lists(device, policies, prefix_list_name_generator)
+        yield from self._cumulus_policy_config(device, communities, policies, prefix_list_name_generator)
 
     def _cumulus_as_path_filters(
             self,
@@ -100,11 +108,12 @@ class CumulusPolicyGenerator(ABC):
                 ("le", str(match.less_equal)) if match.less_equal is not None else ()
             )
 
-    def _cumulus_prefix_lists(self, device: Any, policies: list[RoutingPolicy]) -> Iterable[Sequence[str]]:
-        plists = {p.name: p for p in get_used_prefix_lists(
-            prefix_lists=self.get_prefix_lists(device),
-            policies=policies,
-        )}
+    def _cumulus_prefix_lists(
+            self, device: Any,
+            policies: list[RoutingPolicy],
+            prefix_list_name_generator: PrefixListNameGenerator,
+    ) -> Iterable[Sequence[str]]:
+        plists = {p.name: p for p in self.get_used_prefix_lists(device, prefix_list_name_generator)}
         if not plists.values():
             return
 
@@ -114,7 +123,7 @@ class CumulusPolicyGenerator(ABC):
                 cond: SingleCondition[PrefixMatchValue]
                 for cond in statement.match.find_all(MatchField.ip_prefix):
                     for name in cond.value.names:
-                        mangled_name = mangle_ranged_prefix_list_name(
+                        mangled_name = prefix_list_name_generator.get_prefix_name(
                             name=name,
                             greater_equal=cond.value.greater_equal,
                             less_equal=cond.value.less_equal,
@@ -125,7 +134,7 @@ class CumulusPolicyGenerator(ABC):
                         precessed_names.add(mangled_name)
                 for cond in statement.match.find_all(MatchField.ipv6_prefix):
                     for name in cond.value.names:
-                        mangled_name = mangle_ranged_prefix_list_name(
+                        mangled_name = prefix_list_name_generator.get_prefix_name(
                             name=name,
                             greater_equal=cond.value.greater_equal,
                             less_equal=cond.value.less_equal,
@@ -217,6 +226,7 @@ class CumulusPolicyGenerator(ABC):
             self,
             device: Any,
             condition: SingleCondition[Any],
+            prefix_list_name_generator: PrefixListNameGenerator,
     ) -> Iterator[Sequence[str]]:
         if condition.field == MatchField.community:
             for comm_name in self._get_match_community_names(condition):
@@ -236,7 +246,7 @@ class CumulusPolicyGenerator(ABC):
             return
         if condition.field == MatchField.ip_prefix:
             for name in condition.value.names:
-                mangled_name = mangle_ranged_prefix_list_name(
+                mangled_name = prefix_list_name_generator.get_prefix_name(
                     name=name,
                     greater_equal=condition.value.greater_equal,
                     less_equal=condition.value.less_equal,
@@ -245,7 +255,7 @@ class CumulusPolicyGenerator(ABC):
             return
         if condition.field == MatchField.ipv6_prefix:
             for name in condition.value.names:
-                mangled_name = mangle_ranged_prefix_list_name(
+                mangled_name = prefix_list_name_generator.get_prefix_name(
                     name=name,
                     greater_equal=condition.value.greater_equal,
                     less_equal=condition.value.less_equal,
@@ -268,7 +278,7 @@ class CumulusPolicyGenerator(ABC):
             action: SingleAction[CommunityActionValue],
     ) -> Iterator[Sequence[str]]:
         if action.value.replaced is not None:
-            if action.value.added or action.value.replaced:
+            if action.value.added or action.value.removed:
                 raise NotImplementedError(
                     "Cannot set community together with add/replace on cumulus",
                 )
@@ -421,11 +431,12 @@ class CumulusPolicyGenerator(ABC):
             device: Any,
             policy: RoutingPolicy,
             statement: RoutingPolicyStatement,
+            prefix_list_name_generator: PrefixListNameGenerator,
     ) -> Iterable[Sequence[str]]:
         yield "route-map", policy.name, FRR_RESULT_MAP[statement.result], str(statement.number)
 
         for condition in statement.match:
-            for row in self._cumulus_policy_match(device, condition):
+            for row in self._cumulus_policy_match(device, condition, prefix_list_name_generator):
                 yield FRR_INDENT, *row
         for action in statement.then:
             for row in self._cumulus_policy_then(communities, device, action):
@@ -439,6 +450,7 @@ class CumulusPolicyGenerator(ABC):
             device: Any,
             communities: dict[str, CommunityList],
             policies: list[RoutingPolicy],
+            prefix_list_name_generator: PrefixListNameGenerator,
     ) -> Iterable[Sequence[str]]:
         """ Route maps configuration """
 
@@ -454,5 +466,7 @@ class CumulusPolicyGenerator(ABC):
                     raise RuntimeError(
                         f"Multiple statements have same number {statement.number} for policy `{policy.name}`: "
                         f"`{statement.name}` and `{applied_stmts[statement.number]}`")
-                yield from self._cumulus_policy_statement(communities, device, policy, statement)
+                yield from self._cumulus_policy_statement(
+                    communities, device, policy, statement, prefix_list_name_generator,
+                )
                 applied_stmts[statement.number] = statement.name

{annet-0.16.30 → annet-0.16.32}/annet/rpl_generators/entities.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
@@ -56,15 +57,27 @@ def mangle_united_community_list_name(values: Sequence[str]) -> str:
     return "_OR_".join(values)
 
 
-def mangle_ranged_prefix_list_name(name: str, greater_equal: Optional[int], less_equal: Optional[int]) -> str:
-    if greater_equal is less_equal is None:
-        return name
-    if greater_equal is None:
-        ge_str = "unset"
-    else:
-        ge_str = str(greater_equal)
-    if less_equal is None:
-        le_str = "unset"
-    else:
-        le_str = str(less_equal)
-    return f"{name}_{ge_str}_{le_str}"
+class PrefixListNameGenerator:
+    def __init__(self):
+        self._prefix_lists = defaultdict(set)
+
+    def add_prefix(self, name: str, greater_equal: Optional[int], less_equal: Optional[int]) -> None:
+        self._prefix_lists[name].add((greater_equal, less_equal))
+
+    def is_used(self, name: str):
+        return name in self._prefix_lists
+
+    def get_prefix_name(self, name: str, greater_equal: Optional[int], less_equal: Optional[int]) -> str:
+        if len(self._prefix_lists[name]) == 1:
+            return name
+        if greater_equal is less_equal is None:
+            return name
+        if greater_equal is None:
+            ge_str = "unset"
+        else:
+            ge_str = str(greater_equal)
+        if less_equal is None:
+            le_str = "unset"
+        else:
+            le_str = str(less_equal)
+        return f"{name}_{ge_str}_{le_str}"