annet 1.1.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

annet/rpl_generators/cumulus_frr.py

@@ -1,4 +1,5 @@
 from abc import abstractmethod, ABC
+from collections import defaultdict
 from collections.abc import Sequence
 from ipaddress import ip_interface
 from typing import Any, Literal, Iterable, Iterator, Optional, cast
@@ -12,9 +13,9 @@ from .aspath import get_used_as_path_filters
 from .community import get_used_united_community_lists
 from .entities import (
     AsPathFilter, IpPrefixList, CommunityList, CommunityLogic, CommunityType,
-    mangle_united_community_list_name, PrefixListNameGenerator,
+    mangle_united_community_list_name, PrefixListNameGenerator, group_community_members,
 )
-from .prefix_lists import get_used_prefix_lists, new_prefix_list_name_generator
+
 
 FRR_RESULT_MAP = {
     ResultType.ALLOW: "permit",
@@ -51,12 +52,6 @@ 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()
@@ -66,8 +61,9 @@ class CumulusPolicyGenerator(ABC):
         raise NotImplementedError
 
     def generate_cumulus_rpl(self, device: Any) -> Iterator[Sequence[str]]:
+        prefix_lists = self.get_prefix_lists(device)
         policies = self.get_policies(device)
-        prefix_list_name_generator = new_prefix_list_name_generator(policies)
+        prefix_list_name_generator = PrefixListNameGenerator(prefix_lists, policies)
 
         communities = {c.name: c for c in self.get_community_lists(device)}
         yield from self._cumulus_as_path_filters(device, policies)
@@ -89,60 +85,46 @@ class CumulusPolicyGenerator(ABC):
 
     def _cumulus_prefix_list(
             self,
-            name: str,
             ip_type: Literal["ipv6", "ip"],
-            match: PrefixMatchValue,
             plist: IpPrefixList,
     ) -> Iterable[Sequence[str]]:
-        for i, prefix in enumerate(plist.members):
-            addr_mask = ip_interface(prefix)
+        for i, m in enumerate(plist.members):
+            ge, le = m.or_longer
             yield (
                 ip_type,
                 "prefix-list",
-                name,
+                plist.name,
                 f"seq {i * 5 + 5}",
-                "permit", f"{addr_mask.ip}/{addr_mask.network.prefixlen}",
+                "permit", str(m.prefix),
             ) + (
-                ("ge", str(match.greater_equal)) if match.greater_equal is not None else ()
+                ("ge", str(ge)) if ge is not None else ()
             ) + (
-                ("le", str(match.less_equal)) if match.less_equal is not None else ()
+                ("le", str(le)) if le is not None else ()
             )
 
     def _cumulus_prefix_lists(
             self, device: Any,
             policies: list[RoutingPolicy],
-            prefix_list_name_generator: PrefixListNameGenerator,
+            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
-
-        precessed_names = set()
+        processed_names = set()
         for policy in policies:
             for statement in policy.statements:
                 cond: SingleCondition[PrefixMatchValue]
                 for cond in statement.match.find_all(MatchField.ip_prefix):
                     for name in cond.value.names:
-                        mangled_name = prefix_list_name_generator.get_prefix_name(
-                            name=name,
-                            greater_equal=cond.value.greater_equal,
-                            less_equal=cond.value.less_equal,
-                        )
-                        if mangled_name in precessed_names:
+                        plist = name_generator.get_prefix(name, cond.value)
+                        if plist.name in processed_names:
                             continue
-                        yield from self._cumulus_prefix_list(mangled_name, "ip", cond.value, plists[name])
-                        precessed_names.add(mangled_name)
+                        yield from self._cumulus_prefix_list("ip", plist)
+                        processed_names.add(plist.name)
                 for cond in statement.match.find_all(MatchField.ipv6_prefix):
                     for name in cond.value.names:
-                        mangled_name = prefix_list_name_generator.get_prefix_name(
-                            name=name,
-                            greater_equal=cond.value.greater_equal,
-                            less_equal=cond.value.less_equal,
-                        )
-                        if mangled_name in precessed_names:
+                        plist = name_generator.get_prefix(name, cond.value)
+                        if plist.name in processed_names:
                             continue
-                        yield from self._cumulus_prefix_list(mangled_name, "ipv6", cond.value, plists[name])
-                        precessed_names.add(mangled_name)
+                        yield from self._cumulus_prefix_list("ipv6", plist)
+                        processed_names.add(plist.name)
         yield "!"
 
     def get_used_united_community_lists(
@@ -231,7 +213,7 @@ class CumulusPolicyGenerator(ABC):
             self,
             device: Any,
             condition: SingleCondition[Any],
-            prefix_list_name_generator: PrefixListNameGenerator,
+            name_generator: PrefixListNameGenerator,
     ) -> Iterator[Sequence[str]]:
         if condition.field == MatchField.community:
             for comm_name in self._get_match_community_names(condition):
@@ -251,21 +233,13 @@ class CumulusPolicyGenerator(ABC):
             return
         if condition.field == MatchField.ip_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_list_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "match", "ip address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "match", "ip address prefix-list", plist.name
             return
         if condition.field == MatchField.ipv6_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_list_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "match", "ipv6 address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "match", "ipv6 address prefix-list", plist.name
             return
         if condition.operator is not ConditionOperator.EQ:
             raise NotImplementedError(
@@ -334,9 +308,44 @@ class CumulusPolicyGenerator(ABC):
             raise NotImplementedError("Replacing SOO extcommunity is not supported for Cumulus")
         for community_name in action.value.added:
             yield "set", "extcommunity soo", community_name, "additive"
-        for community_name in action.value.removed:
+        if action.value.removed:
             raise NotImplementedError("SOO extcommunity remove is not supported for Cumulus")
 
+    def _cumulus_extcommunity_type_str(self, comm_type: CommunityType) -> str:
+        if comm_type is CommunityType.SOO:
+            return "soo"
+        elif comm_type is CommunityType.RT:
+            return "rt"
+        elif comm_type is CommunityType.LARGE:
+            raise ValueError("Large community is not subtype of extcommunity")
+        elif comm_type is CommunityType.BASIC:
+            raise ValueError("Basic community is not subtype of extcommunity")
+        else:
+            raise NotImplementedError(f"Community type {comm_type} is not supported on cumulus")
+
+    def _cumulus_then_extcommunity(
+            self,
+            communities: dict[str, CommunityList],
+            device: Any,
+            action: SingleAction[CommunityActionValue],
+    ):
+        if action.value.replaced is not None:
+            if action.value.added or action.value.removed:
+                raise NotImplementedError(
+                    "Cannot set extcommunity together with add/delete on cumulus",
+                )
+            if not action.value.replaced:
+                yield "set", "extcommunity", "none"
+                return
+            members = group_community_members(communities, action.value.replaced)
+            for community_type, replaced_members in members.items():
+                type_str = self._cumulus_extcommunity_type_str(community_type)
+                yield "set", "extcommunity", type_str, *replaced_members
+        if action.value.added:
+            raise NotImplementedError("extcommunity add is not supported for Cumulus")
+        if action.value.removed:
+            raise NotImplementedError("extcommunity remove is not supported for Cumulus")
+
     def _cumulus_then_as_path(
             self,
             device: Any,
@@ -377,6 +386,9 @@ class CumulusPolicyGenerator(ABC):
                 cast(SingleAction[CommunityActionValue], action),
             )
             return
+        if action.field == ThenField.extcommunity:
+            yield from self._cumulus_then_extcommunity(communities, device, action)
+            return
         if action.field == ThenField.extcommunity_rt:
             yield from self._cumulus_then_rt_community(
                 communities,

annet/rpl_generators/entities.py

@@ -1,8 +1,11 @@
+from ipaddress import IPv4Network, IPv6Network, ip_network
 from collections import defaultdict
 from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import Optional, List
+
+from annet.rpl import RoutingPolicy, PrefixMatchValue, OrLonger
 
 
 class CommunityLogic(Enum):
@@ -40,10 +43,48 @@ class AsPathFilter:
     filters: Sequence[str]
 
 
-@dataclass(frozen=True)
+@dataclass
+class IpPrefixListMember:
+    prefix: IPv4Network | IPv6Network
+    or_longer: OrLonger = (None, None)
+
+    def __post_init__(self):
+        self.prefix = ip_network(self.prefix)
+
+
+@dataclass
 class IpPrefixList:
     name: str
-    members: Sequence[str]
+    members: list[IpPrefixListMember]
+
+    def __post_init__(self):
+        for (i, m) in enumerate(self.members):
+            if isinstance(m, str):
+                self.members[i] = IpPrefixListMember(m)
+
+
+def ip_prefix_list(
+        name: str,
+        members_or_str: Sequence[IpPrefixListMember | str],
+        or_longer: OrLonger = (None, None),
+) -> IpPrefixList:
+    members: List[IpPrefixListMember] = []
+    for m in members_or_str:
+        if isinstance(m, str):
+            m = IpPrefixListMember(
+                prefix=ip_network(m),
+                or_longer=or_longer,
+            )
+        elif m.or_longer == (None, None):
+            m = IpPrefixListMember(
+                prefix=m.prefix,
+                or_longer=or_longer,
+            )
+        members.append(m)
+    return IpPrefixList(
+        name=name,
+        members=members,
+    )
 
 
 def arista_well_known_community(community: str) -> str:
@@ -58,26 +99,39 @@ def mangle_united_community_list_name(values: Sequence[str]) -> 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}"
+    def __init__(self, prefix_lists: Sequence[IpPrefixList], policies: Sequence[RoutingPolicy]):
+        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:
+        orig_prefix = self._prefix_lists[name]
+        override_name: Optional[str] = None
+        override_orlonger: Optional[OrLonger] = None
+
+        if any(match.or_longer):
+            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)
+            override_name = f"{orig_prefix.name}_{ge_str}_{le_str}"
+            override_orlonger = match.or_longer
+
+        return IpPrefixList(
+            name=override_name or name,
+            members=[
+                IpPrefixListMember(
+                    x.prefix,
+                    or_longer=override_orlonger or x.or_longer,
+                )
+                for x in orig_prefix.members
+            ],
+        )
+
+
+def group_community_members(
+    all_communities: dict[str, CommunityList], communities: list[str],
+) -> dict[CommunityType, list[str]]:
+    members: dict[CommunityType, list[str]] = defaultdict(list)
+    for community_name in communities:
+        community = all_communities[community_name]
+        members[community.type].extend(community.members)
+    return members

annet/rpl_generators/policy.py

@@ -12,8 +12,9 @@ from annet.rpl.statement_builder import AsPathActionValue, NextHopActionValue, T
 from annet.rpl_generators.entities import (
     arista_well_known_community,
     CommunityList, RDFilter, PrefixListNameGenerator, CommunityLogic, mangle_united_community_list_name,
+    IpPrefixList, group_community_members, CommunityType,
 )
-from annet.rpl_generators.prefix_lists import new_prefix_list_name_generator
+
 
 HUAWEI_MATCH_COMMAND_MAP: dict[str, str] = {
     MatchField.as_path_filter: "as-path-filter {option_value}",
@@ -62,6 +63,10 @@ ARISTA_THEN_COMMAND_MAP: dict[str, str] = {
 class RoutingPolicyGenerator(PartialGenerator, ABC):
     TAGS = ["policy", "rpl", "routing"]
 
+    @abstractmethod
+    def get_prefix_lists(self, device: Any) -> list[IpPrefixList]:
+        raise NotImplementedError()
+
     @abstractmethod
     def get_policies(self, device: Any) -> list[RoutingPolicy]:
         raise NotImplementedError()
@@ -87,7 +92,7 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             condition: SingleCondition[Any],
             communities: dict[str, CommunityList],
             rd_filters: dict[str, RDFilter],
-            prefix_name_generator: PrefixListNameGenerator,
+            name_generator: PrefixListNameGenerator,
     ) -> Iterator[Sequence[str]]:
         if condition.field == MatchField.community:
             if condition.operator is ConditionOperator.HAS:
@@ -136,21 +141,13 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             return
         if condition.field == MatchField.ip_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "if-match", "ip-prefix", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "if-match", "ip-prefix", plist.name
             return
         if condition.field == MatchField.ipv6_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "if-match", "ipv6 address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "if-match", "ipv6 address prefix-list", plist.name
             return
         if condition.field == MatchField.as_path_length:
             if condition.operator is ConditionOperator.EQ:
@@ -248,6 +245,52 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
         if action.value.removed:
             raise NotImplementedError("Extcommunity_soo remove is not supported for huawei")
 
+    def _huawei_render_ext_community_members(
+            self, comm_type: CommunityType, members: list[str]
+    ) -> Sequence[Sequence[str]]:
+        if comm_type is CommunityType.SOO:
+            return "soo", *members
+        if comm_type is CommunityType.RT:
+            return [f"rt {member}" for member in members]
+        elif comm_type is CommunityType.LARGE:
+            raise ValueError("Large community is not subtype of extcommunity")
+        elif comm_type is CommunityType.BASIC:
+            raise ValueError("Basic community is not subtype of extcommunity")
+        else:
+            raise NotImplementedError(f"Community type {comm_type} is not supported on huawei")
+
+    def _huawei_then_extcommunity(
+            self,
+            communities: dict[str, CommunityList],
+            device: Any,
+            action: SingleAction[CommunityActionValue],
+    ):
+        if action.value.replaced is not None:
+            if action.value.added or action.value.removed:
+                raise NotImplementedError(
+                    "Cannot set extcommunity together with add/delete on huawei",
+                )
+            if not action.value.replaced:
+                raise NotImplementedError(
+                    "Cannot reset extcommunity on huawei",
+                )
+
+            members = group_community_members(communities, action.value.replaced)
+            for community_type, replaced_members in members.items():
+                if community_type is CommunityType.SOO:
+                    raise NotImplementedError(
+                        "Cannot set extcommunity soo on huawei",
+                    )
+                rendered_memebers = self._huawei_render_ext_community_members(community_type, replaced_members)
+                yield "apply", "extcommunity", *rendered_memebers
+        if action.value.added:
+            members = group_community_members(communities, action.value.added)
+            for community_type, added_members in members.items():
+                rendered_memebers = self._huawei_render_ext_community_members(community_type, added_members)
+                yield "apply", "extcommunity", *rendered_memebers, "additive"
+        if action.value.removed:
+            raise NotImplementedError("Cannot remove extcommunity on huawei")
+
     def _huawei_then_as_path(
             self,
             device: Any,
@@ -286,6 +329,10 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             yield from self._huawei_then_large_community(communities, device,
                                                          cast(SingleAction[CommunityActionValue], action))
             return
+        if action.field == ThenField.extcommunity:
+            yield from self._huawei_then_extcommunity(communities, device,
+                                                      cast(SingleAction[CommunityActionValue], action))
+            return
         if action.field == ThenField.extcommunity_rt:
             yield from self._huawei_then_extcommunity_rt(communities, device,
                                                          cast(SingleAction[CommunityActionValue], action))
@@ -353,10 +400,11 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                 yield "goto next-node"
 
     def run_huawei(self, device):
+        prefix_lists = self.get_prefix_lists(device)
         policies = self.get_policies(device)
         communities = {c.name: c for c in self.get_community_lists(device)}
         rd_filters = {f.name: f for f in self.get_rd_filters(device)}
-        prefix_name_generator = new_prefix_list_name_generator(policies)
+        prefix_name_generator = PrefixListNameGenerator(prefix_lists, policies)
 
         for policy in self.get_policies(device):
             for statement in policy.statements:
@@ -383,7 +431,7 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             condition: SingleCondition[Any],
             communities: dict[str, CommunityList],
             rd_filters: dict[str, RDFilter],
-            prefix_name_generator: PrefixListNameGenerator,
+            name_generator: PrefixListNameGenerator,
     ) -> Iterator[Sequence[str]]:
         if condition.field == MatchField.community:
             if condition.operator is ConditionOperator.HAS_ANY:
@@ -436,21 +484,13 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             return
         if condition.field == MatchField.ip_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "match", "ip address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "match", "ip address prefix-list", plist.name
             return
         if condition.field == MatchField.ipv6_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "match", "ipv6 address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "match", "ipv6 address prefix-list", plist.name
             return
         if condition.field == MatchField.as_path_length:
             if condition.operator is ConditionOperator.EQ:
@@ -492,12 +532,15 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                 yield "set", "community community-list", *action.value.replaced
             else:
                 yield "set", "community", "none"
-        for community_name in action.value.added:
-            yield "set", "community community-list", community_name, "additive"
-        for community_name in action.value.removed:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set community", arista_well_known_community(comm_value), "delete"
+        if action.value.added:
+            yield "set", "community community-list", *action.value.added, "additive"
+        if action.value.removed:
+            members = [
+                arista_well_known_community(member)
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set community", *members, "delete"
 
     def _arista_then_large_community(
             self,
@@ -520,10 +563,10 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                     first = False
                 else:
                     yield "set", "large-community large-community-list", community_name, "additive"
-        for community_name in action.value.added:
-            yield "set", "large-community large-community-list", community_name, "additive"
-        for community_name in action.value.removed:
-            yield "set large-community large-community-list", community_name, "delete"
+        if action.value.added:
+            yield "set", "large-community large-community-list",  *action.value.added, "additive"
+        if action.value.removed:
+            yield "set large-community large-community-list", *action.value.removed, "delete"
 
     def _arista_then_extcommunity_rt(
             self,
@@ -533,14 +576,20 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
     ) -> Iterator[Sequence[str]]:
         if action.value.replaced is not None:
             raise NotImplementedError("Extcommunity_rt replace is not supported for arista")
-        for community_name in action.value.added:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set", "extcommunity rt", comm_value, "additive"
-        for community_name in action.value.removed:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set extcommunity rt", comm_value, "delete"
+        if action.value.added:
+            members = [
+                f"rt {member}"
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set", "extcommunity", *members, "additive"
+        if action.value.removed:
+            members = [
+                f"rt {member}"
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set extcommunity", *members, "delete"
 
     def _arista_then_extcommunity_soo(
             self,
@@ -550,14 +599,65 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
     ) -> Iterator[Sequence[str]]:
         if action.value.replaced is not None:
             raise NotImplementedError("Extcommunity_soo replace is not supported for arista")
-        for community_name in action.value.added:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set", "extcommunity soo", comm_value, "additive"
-        for community_name in action.value.removed:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set", "extcommunity soo", comm_value, "delete"
+        if action.value.added:
+            members = [
+                f"soo {member}"
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set", "extcommunity", *members, "additive"
+        if action.value.removed:
+            members = [
+                f"soo {member}"
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set", "extcommunity", *members, "delete"
+
+    def _arista_extcommunity_type_str(self, comm_type: CommunityType) -> str:
+        if comm_type is CommunityType.SOO:
+            return "soo"
+        elif comm_type is CommunityType.RT:
+            return "rt"
+        elif comm_type is CommunityType.LARGE:
+            raise ValueError("Large community is not subtype of extcommunity")
+        elif comm_type is CommunityType.BASIC:
+            raise ValueError("Basic community is not subtype of extcommunity")
+        else:
+            raise NotImplementedError(f"Community type {comm_type} is not supported on arista")
+
+    def _arista_render_ext_community_members(
+            self, all_communities: dict[str, CommunityList], communities: list[str],
+    ) -> Iterator[str]:
+        for community_name in communities:
+            community = all_communities[community_name]
+            comm_type = self._arista_extcommunity_type_str(community.type)
+            for member in community.members:
+                yield f"{comm_type} {member}"
+
+    def _arista_then_extcommunity(
+            self,
+            communities: dict[str, CommunityList],
+            device: Any,
+            action: SingleAction[CommunityActionValue],
+    ):
+        if action.value.replaced is not None:
+            if action.value.added or action.value.removed:
+                raise NotImplementedError(
+                    "Cannot set extcommunity together with add/delete on arista",
+                )
+            if not action.value.replaced:
+                yield "set", "extcommunity", "none"
+                return
+            members = list(self._arista_render_ext_community_members(communities, action.value.replaced))
+            yield "set extcommunity", *members
+            return
+        if action.value.added:
+            members = list(self._arista_render_ext_community_members(communities, action.value.added))
+            yield "set extcommunity", *members, "additive"
+        if action.value.removed:
+            members = list(self._arista_render_ext_community_members(communities, action.value.removed))
+            yield "set extcommunity", *members, "delete"
 
     def _arista_then_as_path(
             self,
@@ -605,6 +705,9 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                 communities, device, cast(SingleAction[CommunityActionValue], action),
             )
             return
+        if action.field == ThenField.extcommunity:
+            yield from self._arista_then_extcommunity(communities, device, action)
+            return
         if action.field == ThenField.extcommunity_rt:
             yield from self._arista_then_extcommunity_rt(
                 communities, device, cast(SingleAction[CommunityActionValue], action),
@@ -675,8 +778,9 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                 yield "continue"
 
     def run_arista(self, device):
+        prefix_lists = self.get_prefix_lists(device)
         policies = self.get_policies(device)
-        prefix_name_generator = new_prefix_list_name_generator(policies)
+        prefix_name_generator = PrefixListNameGenerator(prefix_lists, policies)
         communities = {c.name: c for c in self.get_community_lists(device)}
         rd_filters = {f.name: f for f in self.get_rd_filters(device)}