annet 3.13.0__py3-none-any.whl → 3.14.1__py3-none-any.whl

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/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/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/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/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"

annet/rpl_generators/policy.py

@@ -6,13 +6,13 @@ from annet.generators import PartialGenerator
 from annet.rpl import (
     CommunityActionValue,
     ResultType, RoutingPolicyStatement, RoutingPolicy, ConditionOperator, SingleCondition, SingleAction, ActionType,
-    MatchField, PrefixMatchValue,
+    MatchField, PrefixMatchValue, AndCondition, Action,
 )
 from annet.rpl.statement_builder import AsPathActionValue, NextHopActionValue, ThenField
 from annet.rpl_generators.entities import (
     arista_well_known_community,
     CommunityList, RDFilter, PrefixListNameGenerator, CommunityLogic, mangle_united_community_list_name,
-    IpPrefixList, group_community_members, CommunityType,
+    IpPrefixList, group_community_members, CommunityType, JuniperPrefixListNameGenerator
 )
 
 HUAWEI_MATCH_COMMAND_MAP: dict[str, str] = {
@@ -79,6 +79,31 @@ IOSXR_RESULT_MAP = {
     ResultType.DENY: "drop",
     ResultType.NEXT: "pass"
 }
+JUNIPER_MATCH_COMMAND_MAP: dict[str, str] = {
+    MatchField.protocol: "protocol {option_value}",
+    MatchField.metric: "metric {option_value}",
+    MatchField.as_path_filter: "as-path {option_value}",
+    MatchField.local_pref: "local-preference {option_value}",
+    # unsupported: rd
+    # unsupported: interface
+    # unsupported: net_len
+    # unsupported: family
+}
+JUNIPER_THEN_COMMAND_MAP: dict[str, str] = {
+    ThenField.local_pref: "local-preference {option_value}",
+    ThenField.origin: "origin {option_value}",
+    ThenField.tag: "tag {option_value}",
+    ThenField.metric: "metric {option_value}",
+    # unsupported: rpki_valid_state
+    # unsupported: resolution
+    # unsupported: mpls_label
+    # unsupported: metric_type
+}
+JUNIPER_RESULT_MAP = {
+    ResultType.ALLOW: "accept",
+    ResultType.DENY: "reject",
+    ResultType.NEXT: "next term"
+}
 
 
 class RoutingPolicyGenerator(PartialGenerator, ABC):
@@ -1119,3 +1144,343 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                     yield from self._iosxr_statement(
                         communities, rd_filters, device, policy, statement, prefix_name_generator,
                     )
+
+    # Juniper
+    def acl_juniper(self, device):
+        return r"""
+        policy-options       %cant_delete
+            policy-statement
+                ~            %global
+        """
+
+    def _juniper_match_communities(
+            self,
+            section: Literal["", "from"],
+            conditions: list[SingleCondition],
+    ) -> Iterator[Sequence[str]]:
+        names: list[str] = [name for cond in conditions for name in cond.value]
+        operators = {x.operator for x in conditions}
+        if len(names) > 1 and operators != {ConditionOperator.HAS_ANY}:
+            raise NotImplementedError(
+                f"Multiple community match [{' '.join(names)}] without has_any is not supported for Juniper",
+            )
+        yield section, "community", self._juniper_list_bracket(names)
+
+    def _juniper_match_prefix_lists(
+            self,
+            section: Literal["", "from"],
+            conditions: list[SingleCondition[PrefixMatchValue]],
+            name_generator: JuniperPrefixListNameGenerator,
+    ) -> Iterator[Sequence[str]]:
+        operators = {x.operator for x in conditions}
+        supported = {ConditionOperator.HAS_ANY}
+        not_supported = operators - supported
+        if len(conditions) > 1 and not_supported:
+            raise NotImplementedError(
+                f"Multiple prefix match with ops {not_supported} is not supported for Juniper",
+            )
+        for cond in conditions:
+            for name in cond.value.names:
+                prefix_list = name_generator.get_prefix(name, cond.value)
+                plist_type = name_generator.get_type(name, cond.value)
+                flavour = name_generator.get_plist_flavour(prefix_list)
+                if plist_type == "prefix-list" and flavour == "simple":
+                    yield section, "prefix-list", prefix_list.name
+                elif plist_type == "prefix-list" and flavour == "orlonger":
+                    yield section, "prefix-list-filter", prefix_list.name, "orlonger"
+                elif plist_type == "route-filter":
+                    yield section, "route-filter-list", prefix_list.name
+                else:
+                    raise NotImplementedError(
+                        f"Prefix list {prefix_list.name} type {plist_type} flavour {flavour} is not supported for Juniper",
+                    )
+
+    def _juniper_match_as_path_length(
+            self,
+            section: Literal["", "from"],
+            conditions: list[SingleCondition],
+    ) -> Iterator[Sequence[str]]:
+        for condition in conditions:
+            if condition.operator is ConditionOperator.EQ:
+                yield section, "as-path-calc-length", str(condition.value), "equal"
+            elif condition.operator is ConditionOperator.LE:
+                yield section, "as-path-calc-length", str(condition.value), "orlower"
+            elif condition.operator is ConditionOperator.GE:
+                yield section, "as-path-calc-length", str(condition.value), "orhigher"
+            elif condition.operator is ConditionOperator.BETWEEN_INCLUDED:
+                yield section, "as-path-calc-length", str(condition.value[0]), "orhigher"
+                yield section, "as-path-calc-length", str(condition.value[1]), "orlower"
+            else:
+                raise NotImplementedError(
+                    f"Operator {condition.operator} is not supported for {condition.field} on Juniper",
+                )
+
+    def _juniper_match_rd_filter(
+            self,
+            section: Literal["", "from"],
+            conditions: list[SingleCondition[Sequence[str]]],
+    ) -> Iterator[Sequence[str]]:
+        names = [x for c in conditions for x in c.value]
+        operators = {x.operator for x in conditions}
+        supported = {ConditionOperator.HAS_ANY}
+        not_supported = operators - supported
+        if len(names) > 1 and not_supported:
+            raise NotImplementedError(
+                f"Multiple rd_filter matches with ops {not_supported} is not supported for Juniper",
+            )
+        yield section, "route-distinguisher", self._juniper_list_bracket(names)
+
+    def _juniper_match_community_fields(self) -> set[MatchField]:
+        return {
+            MatchField.community,
+            MatchField.extcommunity_rt,
+            MatchField.extcommunity_soo,
+            MatchField.large_community,
+        }
+
+    def _juniper_match_prefix_fields(self) -> set[MatchField]:
+        return {
+            MatchField.ip_prefix,
+            MatchField.ipv6_prefix,
+        }
+
+    def _juniper_is_match_inlined(self, conditions: AndCondition) -> bool:
+        used_fields = {x.field for x in conditions}
+        used_prefix_fields = used_fields & self._juniper_match_prefix_fields()
+        used_community_fields = used_fields & self._juniper_match_community_fields()
+
+        # prefix-list match is never inlined
+        if used_prefix_fields:
+            return False
+
+        # as-path-calc-length is never inlined
+        if MatchField.as_path_length in used_fields:
+            return False
+
+        # only community matches and nothing more
+        if used_community_fields and used_fields == used_community_fields:
+            return True
+
+        # inline when empty or just one match
+        if len(used_fields) <= 1:
+            return True
+        return False
+
+    def _juniper_match(
+            self,
+            policy: RoutingPolicy,
+            section: Literal["", "from"],
+            conditions: AndCondition,
+            prefix_name_generator: JuniperPrefixListNameGenerator,
+    ) -> Iterator[Sequence[str]]:
+        community_fields = self._juniper_match_community_fields()
+        prefix_fields = self._juniper_match_prefix_fields()
+        community_conditions: list[SingleCondition] = []
+        prefix_conditions: list[SingleCondition] = []
+        simple_conditions: list[SingleCondition] = []
+        as_path_length_conditions: list[SingleCondition] = []
+        rd_filter_conditions: list[SingleCondition] = []
+        for condition in conditions:
+            if condition.field in community_fields:
+                community_conditions.append(condition)
+            elif condition.field in prefix_fields:
+                prefix_conditions.append(condition)
+            elif condition.field == MatchField.as_path_length:
+                as_path_length_conditions.append(condition)
+            elif condition.field == MatchField.rd:
+                rd_filter_conditions.append(condition)
+            else:
+                simple_conditions.append(condition)
+
+        if community_conditions:
+            yield from self._juniper_match_communities(section, community_conditions)
+        if prefix_conditions:
+            yield from self._juniper_match_prefix_lists(section, prefix_conditions, prefix_name_generator)
+        if as_path_length_conditions:
+            yield from self._juniper_match_as_path_length(section, as_path_length_conditions)
+        if rd_filter_conditions:
+            yield from self._juniper_match_rd_filter(section, rd_filter_conditions)
+
+        for condition in simple_conditions:
+            if condition.operator is not ConditionOperator.EQ:
+                raise NotImplementedError(
+                    f"`{condition.field}` with operator {condition.operator} in {policy.name} is not supported for Juniper",
+                )
+            if condition.field not in JUNIPER_MATCH_COMMAND_MAP:
+                raise NotImplementedError(f"Match using `{condition.field}` in {policy.name} is not supported for Juniper")
+            yield section, JUNIPER_MATCH_COMMAND_MAP[condition.field].format(option_value=condition.value)
+
+    def _juniper_then_community(
+            self,
+            section: Literal["", "then"],
+            actions: list[SingleAction[CommunityActionValue]]
+        ):
+        # juniper community ops are ORDERED
+        # since data model does not support it
+        # we use the order that makes sense: delete, set, add
+        for single_action in actions:
+            action = single_action.value
+            for name in action.removed:
+                yield section, "community", "delete", name
+
+            if action.replaced is not None:
+                if not action.replaced:
+                    raise NotImplementedError("Empty community.set() is not supported for Juniper")
+                for name in action.replaced:
+                    yield section, "community", "set", name
+
+            for name in action.added:
+                yield section, "community", "add", name
+
+    def _juniper_then_next_hop(
+            self,
+            section: Literal["", "then"],
+            actions: list[SingleAction[NextHopActionValue]],
+        ):
+        if len(actions) > 1:
+            raise NotImplementedError("Only single next-hop action is supported for Juniper")
+
+        action = actions[0]
+        if action.value.target == "self":
+            yield section, "next-hop", "self"
+        elif action.value.target == "discard":
+            yield section, "next-hop", "discard"
+        elif action.value.target == "peer":
+            yield section, "next-hop", "peer-address"
+        elif action.value.target == "ipv4_addr":
+            yield section, "next-hop", action.value.addr
+        elif action.value.target == "ipv6_addr":
+            yield section, "next-hop", action.value.addr.lower()
+        elif action.value.target == "mapped_ipv4":
+            yield section, "next-hop", f"::ffff:{action.value.addr}"
+        else:
+            raise NotImplementedError(f"Next_hop target {action.value.target} is not supported for Juniper")
+
+    def _juniper_list_quote(self, items: list[str]) -> str:
+        joined = " ".join(items)
+        if len(items) > 1:
+            joined = f'"{joined}"'
+        return joined
+
+    def _juniper_list_bracket(self, items: list[str]) -> str:
+        joined = " ".join(items)
+        if len(items) > 1:
+            joined = f"[ {joined} ]"
+        return joined
+
+    def _juniper_then_as_path(
+            self,
+            section: Literal["", "then"],
+            actions: list[SingleAction[AsPathActionValue]],
+        ):
+        if len(actions) > 1:
+            raise NotImplementedError("Only single next-hop action is supported for Juniper")
+
+        action = actions[0]
+        if action.value.expand and action.value.expand_last_as:
+            raise NotImplementedError("Setting both `as_path.expand` and `as_path.expand_last_as` is not supported for Juniper")
+
+        if action.value.prepend:
+            yield section, "as-path-prepend", self._juniper_list_quote(action.value.prepend)
+        if action.value.expand:
+            yield section, "as-path-expand", self._juniper_list_quote(action.value.expand)
+        if action.value.expand_last_as:
+            yield section, "as-path-expand last-as count", action.value.expand_last_as
+        if action.value.set is not None:
+            raise RuntimeError("as_path.set is not supported for Juniper")
+        if action.value.delete:
+            raise RuntimeError("as_path.delete is not supported for Juniper")
+
+    def _juniper_is_then_inlined(self, action: Action) -> bool:
+        used_fields = {x.field for x in action}
+        # inline when no actions permormed
+        if not used_fields:
+            return True
+        return False
+
+    def _juniper_then(
+            self,
+            policy: RoutingPolicy,
+            section: Literal["", "then"],
+            actions: Action,
+    ) -> Iterator[Sequence[str]]:
+        community_actions: list[SingleAction] = []
+        next_hop_actions: list[SingleAction] = []
+        as_path_actions: list[SingleAction] = []
+        simple_actions: list[SingleAction] = []
+        for action in actions:
+            if action.field == ThenField.community:
+                community_actions.append(action)
+            elif action.field == ThenField.extcommunity:
+                community_actions.append(action)
+            elif action.field == ThenField.extcommunity_rt:
+                community_actions.append(action)
+            elif action.field == ThenField.extcommunity_soo:
+                community_actions.append(action)
+            elif action.field == ThenField.large_community:
+                community_actions.append(action)
+            elif action.field == ThenField.next_hop:
+                next_hop_actions.append(action)
+            elif action.field == ThenField.as_path:
+                as_path_actions.append(action)
+            else:
+                simple_actions.append(action)
+
+        if community_actions:
+            yield from self._juniper_then_community(section, community_actions)
+        if next_hop_actions:
+            yield from self._juniper_then_next_hop(section, next_hop_actions)
+        if as_path_actions:
+            yield from self._juniper_then_as_path(section, as_path_actions)
+
+        for action in simple_actions:
+            if action.type not in {ActionType.SET}:
+                raise NotImplementedError(f"Action type {action.type} for `{action.field}` in {policy.name} is not supported for Juniper")
+            if action.field not in JUNIPER_THEN_COMMAND_MAP:
+                raise NotImplementedError(f"Then action using `{action.field}` in {policy.name} is not supported for Juniper")
+            yield section, JUNIPER_THEN_COMMAND_MAP[action.field].format(option_value=action.value)
+
+    def _juniper_statements(
+            self,
+            device: Any,
+            policy: RoutingPolicy,
+            prefix_name_generator: JuniperPrefixListNameGenerator,
+    ) -> Iterator[Sequence[str]]:
+        term_number = 0
+        for statement in policy.statements:
+            if statement.number is not None:
+                term_number = statement.number
+            term_name = statement.name
+            if not term_name:
+                term_name = f"{policy.name}_{term_number}"
+            term_number += 1
+
+            with self.block("term", term_name):
+                # see test_juniper_inline
+                match_inlined = self._juniper_is_match_inlined(statement.match)
+                then_inlined = self._juniper_is_then_inlined(statement.then)
+                match_section: Literal["", "from"] = "from" if match_inlined else ""
+                then_section: Literal["", "then"] = "then" if then_inlined else ""
+
+                if statement.match:
+                    with self.block_if("from", condition=not match_inlined):
+                        yield from self._juniper_match(policy, match_section, statement.match, prefix_name_generator)
+
+                if statement.then:
+                    with self.block_if("then", condition=not then_inlined):
+                        yield from self._juniper_then(policy, then_section, statement.then)
+
+                with self.block_if("then", condition=not then_inlined):
+                    yield then_section, JUNIPER_RESULT_MAP[statement.result]
+
+    def run_juniper(self, device):
+        prefix_lists = self.get_prefix_lists(device)
+        policies = self.get_policies(device)
+        prefix_name_generator = JuniperPrefixListNameGenerator(prefix_lists, policies)
+
+        for policy in policies:
+            with self.block("policy-options"):
+                with self.block("policy-statement", policy.name):
+                    yield from self._juniper_statements(
+                        device, policy, prefix_name_generator,
+                    )

annet/rpl_generators/prefix_lists.py

@@ -1,10 +1,11 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence, Iterable
 from typing import Any, Literal
+from itertools import chain
 
 from annet.generators import PartialGenerator
 from annet.rpl import PrefixMatchValue, MatchField, SingleCondition, RoutingPolicy
-from .entities import IpPrefixList, PrefixListNameGenerator
+from .entities import IpPrefixList, PrefixListNameGenerator, JuniperPrefixListNameGenerator
 
 
 class PrefixListFilterGenerator(PartialGenerator, ABC):
@@ -170,3 +171,68 @@ class PrefixListFilterGenerator(PartialGenerator, ABC):
                             continue
                         yield from self._iosxr_prefixlist(plist)
                         processed_names.add(plist.name)
+
+    def acl_juniper(self, _):
+        return r"""
+        policy-options     %cant_delete
+            prefix-list *
+                ~
+            route-filter-list *
+                ~
+        """
+
+    def _juniper_prefixlist(self, name: str, prefixlist: IpPrefixList):
+        with self.block("policy-options"):
+            with self.block("prefix-list", name):
+                for member in prefixlist.members:
+                    yield f"{member.prefix}"
+
+    def _juniper_router_filter_list(self, name: str, prefixlist: IpPrefixList):
+        with self.block("policy-options"):
+            with self.block("route-filter-list", name):
+                for member in prefixlist.members:
+                    ge, le = member.or_longer
+                    if ge is None and le is None:
+                        yield f"{member.prefix} exact"
+                        continue
+                    if ge is None:
+                        ge = member.prefix.prefixlen
+                    if le is None:
+                        le = member.prefix.max_prefixlen
+                    # may produce config that is not accepted by commit
+                    # since juniper enforces that n <= ge <= le
+                    # where n is prefix len: .../n
+
+                    # this is done specifically to match other generators behaviour
+                    # can be revised in two ways: exeption or enforce via max/min
+                    # but need to be consistent across vendors so will leave it for now
+                    yield f"{member.prefix}", "prefix-length-range", f"/{ge}-/{le}"
+
+    def run_juniper(self, device: Any):
+        prefix_lists = self.get_prefix_lists(device)
+        policies = self.get_policies(device)
+
+        name_generator = JuniperPrefixListNameGenerator(prefix_lists, policies)
+        processed_names: set[str] = set()
+        for policy in policies:
+            for statement in policy.statements:
+                conds = chain(
+                    statement.match.find_all(MatchField.ip_prefix),
+                    statement.match.find_all(MatchField.ipv6_prefix),
+                )
+                cond: SingleCondition[PrefixMatchValue]
+                for cond in conds:
+                    for cond_name in cond.value.names:
+                        plist = name_generator.get_prefix(cond_name, cond.value)
+                        plist_type = name_generator.get_type(cond_name, cond.value)
+
+                        if plist.name not in processed_names:
+                            processed_names.add(plist.name)
+                            if plist_type == "prefix-list":
+                                yield from self._juniper_prefixlist(plist.name, plist)
+                            elif plist_type == "route-filter":
+                                yield from self._juniper_router_filter_list(plist.name, plist)
+                            else:
+                                raise NotImplementedError(
+                                    f"Prefix list {cond_name} type {plist_type} is not supported for Juniper",
+                                )

annet/rpl_generators/rd.py

@@ -54,3 +54,18 @@ class RDFilterFilterGenerator(PartialGenerator, ABC):
                     else:
                         comma = ""
                     yield f"{route_distinguisher}{comma}",
+
+    def acl_juniper(self, _):
+        return r"""
+        policy-options             %cant_delete
+            route-distinguisher
+        """
+
+    def run_juniper(self, device: Any):
+        for rd_filter in self.get_used_rd_filters(device):
+            with self.block("policy-options"):
+                if len(rd_filter.members) == 1:
+                    yield "route-distinguisher", rd_filter.name, "members", rd_filter.members[0]
+                elif len(rd_filter.members) > 1:
+                    joined = " ".join(rd_filter.members)
+                    yield "route-distinguisher", rd_filter.name, "members", f"[ {joined} ]"

annet/rulebook/texts/juniper.rul

@@ -109,8 +109,12 @@ policy-options
     community ~
     prefix-list ~
     policy-statement *
-        ~                 %ordered
-            ~             %global
+        term *               %ordered
+            then
+                community ~  %ordered
+                ~
+            ~                %global
+        ~                    %global
 
 
 firewall

annet/vendors/tabparser.py

@@ -487,7 +487,7 @@ class JuniperFormatter(CommonFormatter):
 
         self._sub_regexs = (
             (re.compile(self._block_begin + r"\s*" + self._block_end + r"$"), ""),  # collapse empty blocks
-            (re.compile(self._block_begin + "(\t# .+)?$"), ""),
+            (re.compile(self._block_begin + r"\s*" + r"(\t# .+)?$"), ""),
             (re.compile(self._statement_end + r"$"), ""),
             (re.compile(r"\s*" + self._block_end + "(\t# .+)?$"), ""),
             (re.compile(self._endofline_comment + r".*$"), ""),
@@ -694,46 +694,35 @@ class RosFormatter(CommonFormatter):
         is_patch: bool,
         context: Optional[FormatterContext] = None
     ):
-        rows = []
-
         if is_patch:
-            items = ((item.row, item.child, item.context) for item in tree.itms)
-        else:
-            items = ((row, child, {}) for row, child in tree.items())
+            raise RuntimeError("Ros not supported blocks in patch")
 
+        rows = []
+
+        items = ((row, child, {}) for row, child in tree.items())
         for row, sub_config, row_context in items:
-            if sub_config or (is_patch and sub_config is not None):
-                rows.append((row, sub_config, row_context))
-            else:
-                rows.append((row, None, row_context))
+            rows.append((row, sub_config if sub_config else None, row_context))
 
-        prev_prow = None
-        prev_prow_context = {}
         for sub_config, row_group in itertools.groupby(rows, lambda x: x[1]):
             if sub_config is None:
-                if prev_prow:
-                    yield prev_prow, prev_prow_context
-                    yield BlockBegin, None
+                blocks, leaf = [], context
+                while leaf:
+                    if leaf.current:
+                        blocks.append(leaf.current[0])
+                    leaf = leaf.parent
+
+                yield " ".join(reversed(blocks)), None
+                yield BlockBegin, None
                 for row, _, row_context in row_group:
                     yield row, row_context
-                if prev_prow:
-                    yield BlockEnd, None
+                yield BlockEnd, None
             else:
                 for row, _, row_context in row_group:
-                    if context and context.parent and context.parent.row:
-                        prev_prow, prev_prow_context = context.parent.current
-                        prow = f"{context.parent.row} {row}"
-                    else:
-                        prow = row
-                    yield prow, row_context
-
-                    yield BlockBegin, None
                     yield from self.blocks_and_context(
                         sub_config,
                         is_patch,
-                        context=FormatterContext(parent=context, current=(prow, row_context))
+                        context=FormatterContext(parent=context, current=(row, row_context))
                     )
-                    yield BlockEnd, None
 
     def _formatted_blocks(self, blocks):
         line = None

{annet-3.13.0.dist-info → annet-3.14.1.dist-info}/METADATA

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

{annet-3.13.0.dist-info → annet-3.14.1.dist-info}/RECORD

@@ -63,7 +63,7 @@ annet/annlib/types.py,sha256=VHU0CBADfYmO0xzB_c5f-mcuU3dUumuJczQnqGlib9M,852
 annet/annlib/netdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/annlib/netdev/db.py,sha256=fI_u5aya4l61mbYSjj4JwlVfi3s7obt2jqERSuXGRUI,1634
 annet/annlib/netdev/devdb/__init__.py,sha256=I-NKzenyjsmUKpmIerQOfZExnnnDpPdNZLdRanyu-Nk,1020
-annet/annlib/netdev/devdb/data/devdb.json,sha256=HI43va6tlOAFRSRnjXR7Ex32B4ZbRH0yvrjzud2apJM,7198
+annet/annlib/netdev/devdb/data/devdb.json,sha256=ptegQaH_HxmAEePlMx52GaiobM2xp1RXEJcvR7IAHGY,7174
 annet/annlib/netdev/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/annlib/netdev/views/dump.py,sha256=rIlyvnA3uM8bB_7oq1nS2KDxTp6dQh2hz-FbNhYIpOU,4630
 annet/annlib/netdev/views/hardware.py,sha256=XvHtRn29SROKtxqMyr86oc1ItUKy36N98ppfuJQL8PY,3235
@@ -101,20 +101,20 @@ annet/mesh/registry.py,sha256=xmWF7yxWXmwqX2_jyMAKrbGd2G9sjb4rYDx4Xk61QKc,9607
 annet/rpl/__init__.py,sha256=8nSiFpXH4OhzRGKr-013nHwwKk5Y50uh2gL7d_IoV8U,757
 annet/rpl/action.py,sha256=PY6W66j908RuqQ1_ioxayqVN-70rxDk5Z59EGHtxI98,1246
 annet/rpl/condition.py,sha256=MJri4MbWtPkLHIsLMAtsIEF7e8IAS9dIImjmJs5vS5U,3418
-annet/rpl/match_builder.py,sha256=mCxRlUp7qrNJDPi0ESvBzdpMUiOpgIk630m26jIzb0s,4787
+annet/rpl/match_builder.py,sha256=Y-FOEDV7n36o-Ul3f6bVSyJ1_020YIIoQiX9lgJLAzI,5068
 annet/rpl/policy.py,sha256=P1Kt-8fHFxEczeP-RwkK_wrGN0p7IR-hOApEd2vC55E,448
 annet/rpl/result.py,sha256=PHFn1zhDeqLBn07nkYw5vsoXew4nTwkklOwqvFWzBLg,141
 annet/rpl/routemap.py,sha256=SIyk73OzPp2oH_XwrDv2xczuY2Zt1VsJmB0TT5r7F5g,2593
 annet/rpl/statement_builder.py,sha256=qKhLS34lygbhtbEIY-6jzs0Aisc6qmNc_iyk9iKPyHE,10076
 annet/rpl_generators/__init__.py,sha256=V4rAZlBaOUSjeQ5eCNmWeD7BSJLIwy0lKU_01grebpc,832
-annet/rpl_generators/aspath.py,sha256=hIH3GNDos8hVzeyCdsD7dD3Ku-meyevfEBWtyLsiwws,2613
-annet/rpl_generators/community.py,sha256=vvjBupVrMn3B2OFDLXxgUq0QQBpp5TWdlJOAYpUxFkc,12818
+annet/rpl_generators/aspath.py,sha256=UXB2iMUgJZdHbcoAwPKycSZ34Zscb7OzOxkS85Nc8W0,3575
+annet/rpl_generators/community.py,sha256=LwkDW-nskDhJMx_CssvQoNyJnYikK9pj6mrxTpRPGUQ,15891
 annet/rpl_generators/cumulus_frr.py,sha256=eABVCpn4ru_BFQJDcPZZEi1EL1cBwfNhtC1mDmC6BwA,21548
-annet/rpl_generators/entities.py,sha256=uO78iG2zHAGra5DqzpfnBgoc6slHEc6wDLvlnoySvJc,3750
+annet/rpl_generators/entities.py,sha256=Eia8zXnHKd4NbvLU-fNjoIxwxCWttzuPiWN9Nr8MQtE,5484
 annet/rpl_generators/execute.py,sha256=wS6e6fwcPWywsHB0gBMqZ17eF0s4YOBgDgwPB_cr5Rw,431
-annet/rpl_generators/policy.py,sha256=a0xuLJ7duYT0YrXipLe2_KvBRJlUt-npM4PM4O5IFqg,52158
-annet/rpl_generators/prefix_lists.py,sha256=sxTPeOJufwogguuhjjMbrGSgW3wm2HNboX9tN3qLitU,6910
-annet/rpl_generators/rd.py,sha256=-l0Dy-t1lIFCLLIzRb_okwU1jxr_kNEds92FyoVS7qs,1999
+annet/rpl_generators/policy.py,sha256=IGKOD2wpBOqo-NW3aOXDogLIPUMtve54IbWbqfVlwgc,68429
+annet/rpl_generators/prefix_lists.py,sha256=lyx6m0QOTgaIFWKvXjlmU1rV9gsjpxmTQ-vPlZ_XPFw,10054
+annet/rpl_generators/rd.py,sha256=mw5-ictMdCQbkFcMi4R8iKqwmOp52Y9HnQuEitT6yrc,2632
 annet/rulebook/__init__.py,sha256=AmcqrLYaoU1-sO2vmtjWZbzsZ44_w7nXncoEVa_hpyk,3997
 annet/rulebook/common.py,sha256=zK1s2c5lc5HQbIlMUQ4HARQudXSgOYiZ_Sxc2I_tHqg,721
 annet/rulebook/deploying.py,sha256=9CMeOUw5L1OWdrccSRfpJyH9H_jH7xWNU1JldviBNrk,3015
@@ -165,7 +165,7 @@ annet/rulebook/texts/iosxr.deploy,sha256=Hu0NkcGv3f1CWUrnbzI3eQOPXJxtH4NNOPRV68I
 annet/rulebook/texts/iosxr.order,sha256=gUp6XHwzqkDsArCUAwtx3rR1qlGfYsHy2vP9oZN2oDk,1922
 annet/rulebook/texts/iosxr.rul,sha256=JMFJ94ORNeDQo_X73iPS6pFUmXYTBuL5pkUypgHcOig,2966
 annet/rulebook/texts/juniper.order,sha256=PpxmcCgeaeP3TyYe3BWvtb24MKYV_BujjCH3HD4lsc8,256
-annet/rulebook/texts/juniper.rul,sha256=wwYGDycZNvQBWxYmxMcOb9rAskidBL-G4ewXhrhX-cQ,2825
+annet/rulebook/texts/juniper.rul,sha256=f6kzTXpek3vYd3-vEdn0TjGjbmkvwHpWwkKIPqI4A_0,2941
 annet/rulebook/texts/nexus.deploy,sha256=9YNAQEw7aQxtYZJbE-dMD6qJrTzs_G92Ifrx3Ft4Wn4,1120
 annet/rulebook/texts/nexus.order,sha256=AZMKCD5Zf_mBOlE36aMDvO4w5rdbepTz1Dsyv7xP9Qs,1834
 annet/rulebook/texts/nexus.rul,sha256=Yo87rreD__P_2uKfZ7aPQuq2gHIi2C1l5zpk2x3PI1M,2622
@@ -183,7 +183,7 @@ annet/rulebook/texts/routeros.rul,sha256=ipfxjj0mjFef6IsUlupqx4BY_Je_OUb8u_U1019
 annet/vendors/__init__.py,sha256=gQcDFlKeWDZB6vxJ_MdPWEoE-C5dg-YgXvgGkuV9YLw,569
 annet/vendors/base.py,sha256=AmM3--gqC-Rpw5Xu_-hqthWZ9EoZRL8x6eOHwadZGbo,1145
 annet/vendors/registry.py,sha256=LgPg4oxWrgxsfpLpJ6OWEGFmUzlVlHzziSXsZTi82uc,2540
-annet/vendors/tabparser.py,sha256=cPHCqq9oZ3TBR0GlV4oCaPA_UZuaEJfyfYb-uh3n5Oo,32167
+annet/vendors/tabparser.py,sha256=-wu5ErbTKtAl4SWGhXG0R1EkDbZkJcCC_7_ZkDpBEuk,31701
 annet/vendors/library/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/vendors/library/arista.py,sha256=J4ltZ7sS_TgIECg2U7fizvxwfS4-s35Of0tNDNWWYbE,1302
 annet/vendors/library/aruba.py,sha256=tvrSFSA43n0uelCv-NLQnqxO01d0y2mrfhncpOX7zoQ,1257
@@ -199,8 +199,8 @@ annet/vendors/library/optixtrans.py,sha256=VdME69Ca4HAEgoaKN21fZxnmmsqqaxOe_HZja
 annet/vendors/library/pc.py,sha256=vfv31_NPi7M-4AUDL89UcpawK2E6xvCpELA209cd1ho,1086
 annet/vendors/library/ribbon.py,sha256=DDOBq-_-FL9dCxqXs2inEWZ-pvw-dJ-A-prA7cKMhec,1216
 annet/vendors/library/routeros.py,sha256=iQa7m_4wjuvcgBOI9gyZwlw1BvzJfOkvUbyoEk-NI9I,1254
-annet-3.13.0.dist-info/licenses/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
-annet-3.13.0.dist-info/licenses/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
+annet-3.14.1.dist-info/licenses/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
+annet-3.14.1.dist-info/licenses/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
 annet_generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet_generators/example/__init__.py,sha256=OJ77uj8axc-FIyIu_Xdcnzmde3oQW5mk5qbODkhuVc8,355
 annet_generators/example/hostname.py,sha256=RloLzNVetEoWPLITzfJ13Nk3CC0yi-cZB1RTd6dnuhI,2541
@@ -213,8 +213,8 @@ annet_generators/rpl_example/generator.py,sha256=EWah19gOH8G-QyNyWqxCqdRi0BK7GbM
 annet_generators/rpl_example/items.py,sha256=HPgxScDvSqJPdz0c2SppDrH82DZYC4zUaniQwcWmh4A,1176
 annet_generators/rpl_example/mesh.py,sha256=z_WgfDZZ4xnyh3cSf75igyH09hGvtexEVwy1gCD_DzA,288
 annet_generators/rpl_example/route_policy.py,sha256=z6nPb0VDeQtKD1NIg9sFvmUxBD5tVs2frfNIuKdM-5c,2318
-annet-3.13.0.dist-info/METADATA,sha256=ZdefKvmfVnjAqz3UKtqNkKtSgGfwzgrNP2J0j5Q-WYY,816
-annet-3.13.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-annet-3.13.0.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
-annet-3.13.0.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
-annet-3.13.0.dist-info/RECORD,,
+annet-3.14.1.dist-info/METADATA,sha256=BKLGnMeB4wRe5P-wSYsu3zPFBxoTIS6_y75rZJ6lz04,816
+annet-3.14.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+annet-3.14.1.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
+annet-3.14.1.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
+annet-3.14.1.dist-info/RECORD,,