annet 3.12.1__tar.gz → 3.14.0__tar.gz

{annet-3.12.1/annet.egg-info → annet-3.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annet
-Version: 3.12.1
+Version: 3.14.0
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-3.12.1 → annet-3.14.0}/annet/adapters/netbox/common/models.py

@@ -189,6 +189,8 @@ class Interface(Entity, Generic[_IpAddressT, _FHRPGroupAssignmentT]):
     lag_min_links: int | None = None
     speed: int | None = None
 
+    custom_fields: Dict[str, Any] = field(default_factory=dict)
+
     ip_addresses: List[_IpAddressT] = field(default_factory=list)
     count_ipaddresses: int = 0
     fhrp_groups: List[_FHRPGroupAssignmentT] = field(default_factory=list)

{annet-3.12.1 → annet-3.14.0}/annet/adapters/netbox/provider.py

@@ -45,12 +45,13 @@ def storage_factory(opts: NetboxStorageOpts) -> Storage:
 
 class NetboxProvider(StorageProvider, AdapterWithName, AdapterWithConfig):
     def __init__(self, url: Optional[str] = None, token: Optional[str] = None, insecure: bool = False,
-                 exact_host_filter: bool = False, threads: int = 1):
+                 exact_host_filter: bool = False, threads: int = 1, all_hosts_filter: dict[str, list[str]] | None = None):
         self.url = url
         self.token = token
         self.insecure = insecure
         self.exact_host_filter = exact_host_filter
         self.threads = threads
+        self.all_hosts_filter = all_hosts_filter
 
     @classmethod
     def with_config(cls, **kwargs: Dict[str, Any]) -> T:

{annet-3.12.1 → annet-3.14.0}/annet/annlib/netdev/devdb/data/devdb.json

@@ -144,7 +144,7 @@
     "PC.Whitebox.Ufispace.S.S9300.S9301_32DB": " S9301-32DB",
     "PC.Whitebox.Ufispace.S.S9300.S9321_64EO": " S9321-64EO",
     "PC.Nebius": "^Nebius",
-    "PC.Nebius.NB-E-BR-DCU-AST2600": "^Nebius NB-E-BR-DCU-AST2600",
+    "PC.Nebius.Octoport": " NB-D-M-CSM-R",
     "PC.Avocent": " [Aa]vocent",
     "PC.Avocent.ACS8000": " (ACS|acs)8000",
 
@@ -189,4 +189,4 @@
     "B4com.CS4132U": "^[Bb]4com B4T-CS4132U.*",
     "B4com.CS4148Q": "^[Bb]4com B4T-CS4148Q.*",
     "B4com.CS4164U": "^[Bb]4com B4T-CS4164U.*"
-}
+}

{annet-3.12.1 → annet-3.14.0}/annet/bgp_models.py

@@ -255,6 +255,8 @@ class FamilyOptions:
     rib_group: bool = False
     loops: int = 0
     advertise_bgp_static: bool = False
+    import_policy: Optional[str] = None
+    export_policy: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -387,7 +389,7 @@ def _used_policies(peer: Union[Peer, PeerGroup, VrfOptions]) -> Iterable[str]:
         yield peer.export_policy
 
 
-def _used_redistribute_policies(opts: Union[GlobalOptions, VrfOptions]) -> Iterable[str]:
+def _used_families_policies(opts: Union[GlobalOptions, VrfOptions]) -> Iterable[str]:
     for family_opts in (
         opts.ipv4_unicast,
         opts.ipv6_unicast,
@@ -400,6 +402,13 @@ def _used_redistribute_policies(opts: Union[GlobalOptions, VrfOptions]) -> Itera
                 yield red.policy
         if family_opts.aggregate and family_opts.aggregate.policy:
             yield family_opts.aggregate.policy
+        for aggregate in family_opts.aggregates:
+            if aggregate.policy:
+                yield aggregate.policy
+        if family_opts.export_policy:
+            yield family_opts.export_policy
+        if family_opts.import_policy:
+            yield family_opts.import_policy
 
 
 def extract_policies(config: BgpConfig) -> Sequence[str]:
@@ -407,11 +416,11 @@ def extract_policies(config: BgpConfig) -> Sequence[str]:
     for vrf in config.global_options.vrf.values():
         for group in vrf.groups:
             result.extend(_used_policies(group))
-        result.extend(_used_redistribute_policies(vrf))
+        result.extend(_used_families_policies(vrf))
         result.extend(_used_policies(vrf))
     for group in config.global_options.groups:
         result.extend(_used_policies(group))
     for peer in config.peers:
         result.extend(_used_policies(peer))
-    result.extend(_used_redistribute_policies(config.global_options))
+    result.extend(_used_families_policies(config.global_options))
     return result

{annet-3.12.1 → annet-3.14.0}/annet/mesh/device_models.py

@@ -36,6 +36,8 @@ class FamilyOptions(BaseMeshModel):
     rib_group: bool
     loops: int
     advertise_bgp_static: bool
+    import_policy: Optional[str]
+    export_policy: Optional[str]
 
 
 class _FamiliesMixin:

{annet-3.12.1 → annet-3.14.0}/annet/rpl/match_builder.py

@@ -95,8 +95,12 @@ class Checkable:
     def match_v6(
             self,
             *names: str,
-            or_longer: OrLonger = (None, None),
+            or_longer: bool | OrLonger = (None, None),
     ) -> SingleCondition[PrefixMatchValue]:
+        if or_longer is True:
+            or_longer = (None, 128)
+        if or_longer is False:
+            or_longer = (None, None)
         return SingleCondition(
             MatchField.ipv6_prefix,
             ConditionOperator.CUSTOM,
@@ -106,8 +110,12 @@ class Checkable:
     def match_v4(
             self,
             *names: str,
-            or_longer: OrLonger = (None, None),
+            or_longer: bool | OrLonger = (None, None),
     ) -> SingleCondition[PrefixMatchValue]:
+        if or_longer is True:
+            or_longer = (None, 32)
+        if or_longer is False:
+            or_longer = (None, None)
         return SingleCondition(
             MatchField.ip_prefix,
             ConditionOperator.CUSTOM,

{annet-3.12.1 → annet-3.14.0}/annet/rpl_generators/aspath.py

@@ -71,3 +71,25 @@ class AsPathFilterGenerator(PartialGenerator, ABC):
                     else:
                         comma = ""
                     yield "ios-regex", f"'{filter_item}'{comma}"
+
+    def acl_juniper(self, _):
+        return r"""
+        policy-options  %cant_delete
+            as-path ~
+        """
+
+    def _juniper_as_path(self, name: str, as_path_member: str):
+        if not as_path_member.isnumeric():
+            as_path_member = f'"{as_path_member}"'
+        yield "as-path", name, as_path_member
+
+    def run_juniper(self, device: Any):
+        for as_path_filter in self.get_used_as_path_filters(device):
+            # TODO could be implemented via as-path-groups
+            # But we need to provide as_path_filters to policy generator
+            # To select between regular as-path and as-path-groups
+            if len(as_path_filter.filters) > 1:
+                raise NotImplementedError(f"Multiple elements in as_path_filter {as_path_filter.name} is not supported for Juniper")
+
+            with self.block("policy-options"):
+                yield from self._juniper_as_path(as_path_filter.name, as_path_filter.filters[0])

{annet-3.12.1 → annet-3.14.0}/annet/rpl_generators/community.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from collections.abc import Sequence, Collection, Iterator
+from collections import defaultdict
+from collections.abc import Sequence, Collection, Iterator, Mapping
 from typing import Any
 
 from annet.generators import PartialGenerator
@@ -12,6 +13,7 @@ from .entities import (
 def get_used_community_lists(
         communities: Collection[CommunityList], policies: Collection[RoutingPolicy],
 ) -> list[CommunityList]:
+    assert_unique_names(communities)
     communities_dict = {c.name: c for c in communities}
     used_communities: set[str] = set()
     for policy in policies:
@@ -44,6 +46,7 @@ def get_used_united_community_lists(
     """
     Return communities united into groups according to HAS_ANY policy
     """
+    assert_unique_names(communities)
     communities_dict = {c.name: c for c in communities}
     used_communities: dict[str, list[CommunityList]] = {}
     for policy in policies:
@@ -93,6 +96,17 @@ def get_used_united_community_lists(
     ]
 
 
+def assert_unique_names(communities: Collection[CommunityList]) -> None:
+    duplicated: list[str] = []
+    seen_names: set[str] = set()
+    for c in communities:
+        if c.name in seen_names:
+            duplicated.append(c.name)
+        seen_names.add(c.name)
+    if duplicated:
+        raise NotImplementedError(f"Non-unique community-list names are not supported: {duplicated}")
+
+
 class CommunityListGenerator(PartialGenerator, ABC):
     TAGS = ["policy", "rpl", "routing"]
 
@@ -274,3 +288,61 @@ class CommunityListGenerator(PartialGenerator, ABC):
     def run_iosxr(self, device):
         for community_list in self.get_used_community_lists(device):
             yield from self._iosxr_community_list(community_list)
+
+    def acl_juniper(self, _) -> str:
+        return r"""
+        policy-options  %cant_delete
+            community ~
+        """
+
+    def _juniper_community_list(self, name: str, community_lists: list[CommunityList]) -> Iterator[Sequence[str]]:
+        members: list[str] = []
+        logic: set[CommunityLogic] = set()
+        for community_list in community_lists:
+            prefix: str
+            if community_list.type is CommunityType.BASIC:
+                prefix = ""
+            elif community_list.type is CommunityType.RT:
+                prefix = "target:"
+            elif community_list.type is CommunityType.SOO:
+                prefix = "origin:"
+            elif community_list.type is CommunityType.LARGE:
+                prefix = "large:"
+            else:
+                raise NotImplementedError(f"CommunityList {name}: type {community_list.type} not implemented for Juniper")
+
+            logic.add(community_list.logic)
+            for community in community_list.members:
+                members.append(prefix + community)
+
+        if len(members) > 1 and logic != {CommunityLogic.AND}:
+            raise NotImplementedError(f"CommunityList {name}: only AND logic between members is implemeted for Juniper")
+
+        definition = ["community", name, "members"]
+        with self.block("policy-options"):
+            if len(members) == 1:
+                yield *definition, *members
+            if len(members) > 1:
+                yield *definition, "[", *members, "]"
+
+    def run_juniper(self, device):
+        # Juniper allows different community types
+        # so we write generator in a generic way to reflect that.
+        #
+        # But get_used_community_lists DOES NOT allow multiple names
+        # This is in part because juniper does not have a type-aware match
+        # It would mean that there is no way to describe a following config via rpl.py:
+        #
+        #    CommunityList("COMM_LIST", ["65000:4000"], CommunityType.BASIC),
+        #    CommunityList("COMM_LIST", ["65000:4000"], CommunityType.RT),
+        #
+        #    # match only route-target but not basic one
+        #    with route(R.extcommunity_rt.has("COMM_LIST")) as rule:
+        #       ...
+        used = self.get_used_community_lists(device)
+        by_name: Mapping[str, list[CommunityList]] = defaultdict(list)
+        for community_list in used:
+            by_name[community_list.name].append(community_list)
+
+        for name, community_lists in by_name.items():
+            yield from self._juniper_community_list(name, community_lists)

{annet-3.12.1 → annet-3.14.0}/annet/rpl_generators/entities.py

@@ -3,7 +3,7 @@ from collections import defaultdict
 from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional, List
+from typing import Optional, List, Literal
 
 from annet.rpl import RoutingPolicy, PrefixMatchValue, OrLonger
 
@@ -103,12 +103,12 @@ class PrefixListNameGenerator:
         self._prefix_lists = {x.name: x for x in prefix_lists}
         self._policies = {x.name: x for x in policies}  # this is here for a later use ~azryve@
 
-    def get_prefix(self, name: str, match: PrefixMatchValue) -> IpPrefixList:
+    def get_prefix(self, name: str, match: PrefixMatchValue | None) -> IpPrefixList:
         orig_prefix = self._prefix_lists[name]
         override_name: Optional[str] = None
         override_orlonger: Optional[OrLonger] = None
 
-        if any(match.or_longer):
+        if match and match.or_longer != (None, None):
             ge, le = match.or_longer
             ge_str = "unset" if ge is None else str(ge)
             le_str = "unset" if le is None else str(le)
@@ -135,3 +135,50 @@ def group_community_members(
         community = all_communities[community_name]
         members[community.type].extend(community.members)
     return members
+
+
+class JuniperPrefixListNameGenerator(PrefixListNameGenerator):
+    def get_prefix(self, name: str, match: PrefixMatchValue | None) -> IpPrefixList:
+        plist = super().get_prefix(name, match)
+        flavour = self.get_plist_flavour(plist)
+        # keep the orginal name for an orlonger match
+        if flavour != "custom":
+            plist.name = name
+        return plist
+
+    def get_type(self, name: str, match: PrefixMatchValue | None) -> Literal["prefix-list", "route-filter"]:
+        orig_plist = self.get_prefix(name, None)
+        plist = self.get_prefix(name, match)
+        orig_flavour = self.get_plist_flavour(orig_plist)
+        flavour = self.get_plist_flavour(plist)
+        if orig_flavour == "custom" or flavour == "custom":
+            return "route-filter"
+        else:
+            return "prefix-list"
+
+    def get_plist_flavour(self, plist: IpPrefixList) -> Literal["simple", "orlonger", "custom"]:
+        is_orlonger: bool = False
+        is_custom: bool = False
+        for m in plist.members:
+            ge, le = m.or_longer
+
+            # or_longer != (None, None)
+            if ge is not None or le is not None:
+                is_orlonger = True
+
+            # orlonger != (n, None), where n is .../n
+            if ge is not None and ge != m.prefix.prefixlen:
+                is_custom = True
+                break
+
+            # orlonger != (None, n), where n is 32 or 128 (ipv4/ipv6)
+            if le is not None and le != m.prefix.max_prefixlen:
+                is_custom = True
+                break
+
+        if is_custom:
+            return "custom"
+        elif is_orlonger:
+            return "orlonger"
+        else:
+            return "simple"