annet 3.4.1__py3-none-any.whl → 3.5.0__py3-none-any.whl

annet/__init__.py

@@ -11,7 +11,7 @@ from contextlog import patch_logging, patch_threading
 from valkit.python import valid_logging_level
 
 import annet.argparse
-from annet.annlib import tabparser  # pylint: disable=unused-import
+from annet.vendors import tabparser  # pylint: disable=unused-import
 from annet.annlib.errors import (  # pylint: disable=wrong-import-position
     DeployCancelled,
     ExecError,

annet/adapters/netbox/common/models.py

@@ -101,7 +101,7 @@ class IpAddress(DumpableView, Generic[_PrefixT]):
 
 @dataclass
 class InterfaceConnectedEndpoint(Entity):
-    device: Entity
+    device: Entity | None
 
 
 @dataclass
@@ -151,14 +151,22 @@ class Interface(Entity, Generic[_IpAddressT]):
     speed: int | None = None
 
     def add_addr(self, address_mask: str, vrf: str | None) -> None:
+        addr = ip_interface(address_mask)
+
+        # when comparing ip addressess
+        # we dont care about the vrf of an addr
+        # because the actual vrf will be
+        # determined by an interface's vrf
+        # and there can be only one
+        #
+        # also we dont care about a mask
+        # because no device will allow
+        # the same addr with multiple masks
         for existing_addr in self.ip_addresses:
-            if existing_addr.address == address_mask and (
-                    (existing_addr.vrf is None and vrf is None) or
-                    (existing_addr.vrf is not None and existing_addr.vrf.name == vrf)
-            ):
+            existing = ip_interface(existing_addr.address)
+            if existing.ip == addr.ip:
                 return
 
-        addr = ip_interface(address_mask)
         vrf_obj = vrf_object(vrf)
         if isinstance(addr, IPv6Interface):
             family = IpFamily(value=6, label="IPv6")

annet/annlib/command.py

@@ -19,7 +19,8 @@ class Command:
     cmd: str
     questions: Optional[List[Question]] = None
     exc_handler: Optional[List[Question]] = None
-    timeout: Optional[int] = None
+    timeout: Optional[int] = None  # total timeout
+    read_timeout: Optional[int] = None  # timeout between consecutive reads
     suppress_nonzero: bool = False
     suppress_eof: bool = False
 

annet/annlib/filter_acl.py

@@ -2,7 +2,8 @@ import collections
 import re
 import typing
 
-from . import patching, tabparser
+from . import patching
+from annet.vendors import tabparser
 from .diff import diff_ops, ops_sign
 from .rbparser import acl
 

annet/annlib/patching.py

@@ -17,7 +17,7 @@ from .rbparser import platform
 from .rbparser.ordering import compile_ordering_text
 from .rulebook.common import call_diff_logic
 from .rulebook.common import default as common_default
-from .tabparser import CommonFormatter
+from annet.vendors.tabparser import CommonFormatter
 from .types import Diff, Op
 from ..vendors import registry_connector
 

annet/annlib/rbparser/syntax.py

@@ -2,7 +2,8 @@ import functools
 import re
 from collections import OrderedDict as odict
 
-from annet.annlib import lib, tabparser
+from annet.annlib import lib
+from annet.vendors import tabparser
 
 
 # =====

annet/api/__init__.py

@@ -31,7 +31,8 @@ from annet import cli_args
 from annet import diff as ann_diff
 from annet import filtering
 from annet import gen as ann_gen
-from annet import patching, rulebook, tabparser, tracing
+from annet import patching, rulebook, tracing
+from annet.vendors import tabparser
 from annet.annlib import jsontools
 from annet.annlib.netdev.views.hardware import HardwareView
 from annet.annlib.types import GeneratorType
@@ -188,8 +189,6 @@ def _print_pre_as_diff(pre, show_rules, indent, file=None, _level=0):
             (Op.AFFECTED, colorama.Fore.CYAN + " "),
         ]:
             items = content["items"].items()
-            if not content["attrs"]["multiline"]:
-                items = sorted(items, key=itemgetter(0))
             for (_, diff) in items:  # pylint: disable=redefined-outer-name
                 if show_rules and not rule_printed and not raw_rule == "__MULTILINE_BODY__":
                     print("%s%s# %s%s%s" % (colorama.Style.BRIGHT, colorama.Fore.BLACK, (indent * _level),

annet/bgp_models.py

@@ -139,7 +139,15 @@ class BFDTimers:
     multiplier: int = 4
 
 
-Family = Literal["ipv4_unicast", "ipv6_unicast", "ipv4_labeled_unicast", "ipv6_labeled_unicast", "l2vpn_evpn"]
+Family = Literal[
+    "ipv4_unicast",
+    "ipv6_unicast",
+    "ipv4_vpn_unicast",
+    "ipv6_vpn_unicast",
+    "ipv4_labeled_unicast",
+    "ipv6_labeled_unicast",
+    "l2vpn_evpn",
+]
 
 
 @dataclass(frozen=True)

annet/deploy_ui.py

@@ -5,6 +5,7 @@ import os
 import sys
 import math
 import asyncio
+import platform
 import textwrap
 import time
 import traceback
@@ -23,7 +24,7 @@ try:
 except ImportError:
     curses = None
 
-uname = os.uname()[0]
+uname = platform.uname()[0]
 NCURSES_SIZE_T = 2 ** 15 - 1
 MIN_CONTENT_HEIGHT = 20
 

annet/diff.py

@@ -6,7 +6,7 @@ from itertools import groupby
 from pathlib import Path
 from typing import Any, Dict, Generator, List, Mapping, Optional, Protocol, Tuple, Union
 
-from annet import cli_args, filtering, patching, rulebook, tabparser
+from annet import cli_args, filtering, patching, rulebook
 from annet.annlib import jsontools
 from annet.annlib.diff import (  # pylint: disable=unused-import
     colorize_line,
@@ -22,7 +22,7 @@ from annet.connectors import CachedConnector
 from annet.output import output_driver_connector
 from annet.storage import Device
 from annet.types import Diff, PCDiff, PCDiffFile
-from annet.vendors import registry_connector
+from annet.vendors import registry_connector, tabparser
 
 from .gen import Loader, old_new
 

annet/executor.py

@@ -162,7 +162,7 @@ class DeferredFileWrite:
             raise Exception()
 
     def write(self, data):
-        with open(self._file, self._mode) as fh:
+        with open(self._file, self._mode, encoding="utf-8") as fh:
             fh.write(data)
 
     def close(self):

annet/gen.py

@@ -25,7 +25,8 @@ from typing import (
 import tabulate
 from contextlog import get_logger
 
-from annet import generators, implicit, patching, tabparser, tracing
+from annet import generators, implicit, patching, tracing
+from annet.vendors import tabparser
 from annet.annlib import jsontools
 from annet.annlib.rbparser.acl import compile_acl_text
 from annet.cli_args import DeployOptions, GenOptions, ShowGenOptions

annet/generators/__init__.py

@@ -11,7 +11,7 @@ from typing import FrozenSet, Iterable, List, Optional, Union
 
 from contextlog import get_logger
 
-from annet import patching, tabparser, tracing
+from annet import patching, tracing
 from annet.annlib.rbparser.acl import compile_acl_text
 from annet.cli_args import GenSelectOptions, ShowGeneratorsOptions
 from annet.lib import get_context
@@ -24,7 +24,7 @@ from annet.types import (
     GeneratorPartialRunArgs,
     GeneratorResult,
 )
-from annet.vendors import registry_connector
+from annet.vendors import registry_connector, tabparser
 
 from .base import BaseGenerator
 from .base import ParamsList as ParamsList

annet/generators/base.py

@@ -5,7 +5,8 @@ import contextlib
 import textwrap
 from typing import Union, List
 
-from annet import tabparser, tracing
+from annet import tracing
+from annet.vendors import tabparser
 from annet.tracing import tracing_connector
 from .exceptions import InvalidValueFromGenerator
 

annet/implicit.py

@@ -133,9 +133,9 @@ def _implicit_tree(device):
                         no shutdown
             """
     elif device.hw.Cisco:
-        # C2900/C3500/C3600 does not support the MTU on a per-interface basis
+        # C2900/C3500/C3600/AIR does not support the MTU on a per-interface basis
         if device.hw.Cisco.Catalyst.C2900 or device.hw.Cisco.Catalyst.C3500 \
-           or device.hw.Cisco.Catalyst.C3600:
+           or device.hw.Cisco.Catalyst.C3600 or device.hw.Cisco.AIR:
             text += r"""
                 !interface */\S*Ethernet\S+/
                     no shutdown

annet/mesh/device_models.py

@@ -40,12 +40,16 @@ class _FamiliesMixin:
     def __init__(self, **kwargs):
         kwargs.setdefault("ipv4_unicast", FamilyOptions(family="ipv4_unicast"))
         kwargs.setdefault("ipv6_unicast", FamilyOptions(family="ipv6_unicast"))
+        kwargs.setdefault("ipv4_vpn_unicast", FamilyOptions(family="ipv4_vpn_unicast"))
+        kwargs.setdefault("ipv6_vpn_unicast", FamilyOptions(family="ipv6_vpn_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_vpn_unicast: Annotated[FamilyOptions, Merge()]
+    ipv6_vpn_unicast: Annotated[FamilyOptions, Merge()]
     ipv4_labeled_unicast: Annotated[FamilyOptions, Merge()]
     ipv6_labeled_unicast: Annotated[FamilyOptions, Merge()]
     l2vpn_evpn: Annotated[FamilyOptions, Merge()]
@@ -55,6 +59,8 @@ class VrfOptions(_FamiliesMixin, BaseMeshModel):
     def __init__(self, vrf_name: str, **kwargs):
         kwargs.setdefault("ipv4_unicast", FamilyOptions(family="ipv4_unicast", vrf_name=vrf_name))
         kwargs.setdefault("ipv6_unicast", FamilyOptions(family="ipv6_unicast", vrf_name=vrf_name))
+        kwargs.setdefault("ipv4_vpn_unicast", FamilyOptions(family="ipv4_unicast", vrf_name=vrf_name))
+        kwargs.setdefault("ipv6_vpn_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))

annet/mesh/executor.py

@@ -194,7 +194,7 @@ class MeshExecutor:
         for rule in self._registry.lookup_virtual(device.fqdn):
             for order_number in rule.num:
                 handler_name = self._handler_name(rule.handler)
-                logger.debug("Running direct handler: %s", handler_name)
+                logger.debug("Running virtual handler: %s", handler_name)
                 session = MeshSession()
                 peer_device = VirtualLocal(rule.match, device)
                 peer_virtual = VirtualPeer(num=order_number)
@@ -219,11 +219,6 @@ class MeshExecutor:
                         f"peer data for device `{device.fqdn}`:\n" + str(e)
                     ) from e
 
-                if not hasattr(device_dto, "svi"):
-                    raise ValueError(
-                        f"Handler `{handler_name}` did not provide `svi` number. "
-                        "Virtual peer must be connected to SVI interface."
-                    )
                 pair = VirtualPair(local=device_dto, connected=virtual_dto)
                 virtual_peers.append(pair)
         return virtual_peers
@@ -345,11 +340,11 @@ class MeshExecutor:
         target_interface.add_addr(changes.addr, changes.vrf)
         return target_interface.name
 
-    def _apply_indirect_interface_changes(
-            self, device: Device, neighbor: Device, ifname: Optional[str], changes: InterfaceChanges,
+    def _apply_nondirect_interface_changes(
+            self, device: Device, ifname: Optional[str], changes: InterfaceChanges,
     ) -> Optional[str]:
         if changes.lag is not None:
-            raise ValueError("LAG creation unsupported for indirect peers")
+            raise ValueError("LAG creation unsupported for indirect and virtual peers")
         elif changes.subif is not None:
             target_interface = device.add_subif(ifname, changes.subif)
         elif changes.svi is not None:
@@ -363,9 +358,6 @@ class MeshExecutor:
         target_interface.add_addr(changes.addr, changes.vrf)
         return target_interface.name
 
-    def _apply_virtual_interface_changes(self, device: Device, local: VirtualLocalDTO) -> str:
-        return device.add_svi(local.svi).name  # we check if SVI configured in execute method
-
     def execute_for(self, device: Device) -> BgpConfig:
         all_fqdns = self._storage.resolve_all_fdnds()
 
@@ -378,23 +370,23 @@ class MeshExecutor:
                 device,
                 direct_pair.device,
                 direct_pair.ports,
-                to_interface_changes(direct_pair.local),
+                to_interface_changes(direct_pair.local, direct_pair.connected),
             )
             peers.append(self._to_bgp_peer(direct_pair, target_interface))
 
         for virtual_pair in self._execute_virtual(device):
-            target_interface = self._apply_virtual_interface_changes(
+            target_interface = self._apply_nondirect_interface_changes(
                 device,
-                virtual_pair.local,
+                getattr(virtual_pair.local, "ifname", None),
+                to_interface_changes(virtual_pair.local, virtual_pair.connected),
             )
             peers.append(self._virtual_to_bgp_peer(virtual_pair, target_interface))
 
         for connected_pair in self._execute_indirect(device, all_fqdns):
-            target_interface = self._apply_indirect_interface_changes(
+            target_interface = self._apply_nondirect_interface_changes(
                 device,
-                connected_pair.device,
                 getattr(connected_pair.local, "ifname", None),
-                to_interface_changes(connected_pair.local),
+                to_interface_changes(connected_pair.local, connected_pair.connected),
             )
             peers.append(self._to_bgp_peer(connected_pair, target_interface))
 

annet/mesh/models_converter.py

@@ -17,7 +17,7 @@ LocalDTO = Union[DirectPeerDTO, IndirectPeerDTO, VirtualLocalDTO]
 
 @dataclass
 class InterfaceChanges:
-    addr: str
+    addr: Optional[str] = None
     lag: Optional[int] = None
     lag_links_min: Optional[int] = None
     svi: Optional[int] = None
@@ -67,7 +67,17 @@ retort = Retort(
 )
 
 to_bgp_global_options = retort.get_loader(GlobalOptions)
-to_interface_changes = retort.get_loader(InterfaceChanges)
+
+
+def to_interface_changes(local: LocalDTO, peer: PeerDTO) -> InterfaceChanges:
+    return InterfaceChanges(
+        addr=getattr(local, "addr", None),
+        lag_links_min=getattr(local, "lag_links_min", None),
+        svi=getattr(local, "svi", None),
+        subif=getattr(local, "subif", None),
+        vrf=getattr(peer, "vrf", None),
+        lag=getattr(local, "lag", None),
+    )
 
 
 def to_bgp_peer(local: LocalDTO, connected: PeerDTO, connected_hostname: str, interface: Optional[str]) -> Peer:

annet/mesh/peer_models.py

@@ -100,14 +100,10 @@ class IndirectPeerDTO(MeshSession, _OptionsDTO):
     svi: Optional[int]
 
 
-class VirtualLocalDTO(_OptionsDTO):
-    asnum: Union[int, str]
+class VirtualLocalDTO(MeshSession, _OptionsDTO):
     pod: int
     addr: str
     description: str
-
-    import_policy: str
-    export_policy: str
     update_source: str
 
     svi: int

annet/parallel.py

@@ -156,12 +156,6 @@ def _pool_worker(pool, index, task_queue, done_queue):
                 capture_output_ctx = capture_output(cap_stdout, cap_stderr)
 
                 with invoke_span_ctx as invoke_span, capture_output_ctx as _:
-                    invoke_trace_id = invoke_span.get_span_context().trace_id
-                    if invoke_trace_id:
-                        span.set_attribute(
-                            "link",
-                            f"https://t.yandex-team.ru/trace/{invoke_trace_id:x}"
-                        )
                     invoke_span.set_attribute("func", pool.func.__name__)
                     invoke_span.set_attribute("worker.id", worker_id)
                     if device_id:

annet/rpl/match_builder.py

@@ -84,7 +84,7 @@ class Checkable:
         self.interface = ConditionFactory[str](MatchField.interface, ["=="])
         self.protocol = ConditionFactory[str](MatchField.protocol, ["=="])
         self.net_len = ConditionFactory[int](MatchField.net_len, ["==", "!="])
-        self.local_pref = ConditionFactory[int](MatchField.local_pref, ["<"])
+        self.local_pref = ConditionFactory[int](MatchField.local_pref, ["<", "==", ">=", "<=", "BETWEEN_INCLUDED"])
         self.metric = ConditionFactory[int](MatchField.metric, ["=="])
         self.family = ConditionFactory[int](MatchField.family, ["=="])
         self.as_path_length = ConditionFactory[int](MatchField.as_path_length, ["==", ">=", "<=", "BETWEEN_INCLUDED"])

annet/rpl_generators/aspath.py

@@ -55,3 +55,19 @@ class AsPathFilterGenerator(PartialGenerator, ABC):
         for as_path_filter in self.get_used_as_path_filters(device):
             values = "_".join((x for x in as_path_filter.filters if x != ".*"))
             yield "ip as-path access-list", as_path_filter.name, "permit", f"_{values}_"
+
+    def acl_iosxr(self, _):
+        return r"""
+        as-path-set *
+            ~ %global=1
+        """
+
+    def run_iosxr(self, device: Any):
+        for as_path_filter in self.get_used_as_path_filters(device):
+            with self.block("as-path-set", as_path_filter.name):
+                for n, filter_item in enumerate(as_path_filter.filters):
+                    if n + 1 < len(as_path_filter.filters):
+                        comma = ","
+                    else:
+                        comma = ""
+                    yield "ios-regex", f"'{filter_item}'{comma}"

annet/rpl_generators/community.py

@@ -1,9 +1,9 @@
 from abc import ABC, abstractmethod
-from collections.abc import Sequence, Collection
+from collections.abc import Sequence, Collection, Iterator
 from typing import Any
 
 from annet.generators import PartialGenerator
-from annet.rpl import RouteMap, SingleCondition, MatchField, ThenField, RoutingPolicy, ConditionOperator
+from annet.rpl import SingleCondition, MatchField, ThenField, RoutingPolicy, ConditionOperator
 from .entities import (
     CommunityList, CommunityLogic, CommunityType, arista_well_known_community, mangle_united_community_list_name,
 )
@@ -25,7 +25,8 @@ def get_used_community_lists(
                     used_communities.update(condition.value)
             for then_field in (
                     ThenField.community, ThenField.large_community,
-                    ThenField.extcommunity_rt, ThenField.extcommunity_soo
+                    ThenField.extcommunity_rt, ThenField.extcommunity_soo,
+                    ThenField.extcommunity,
             ):
                 for action in statement.then.find_all(then_field):
                     if action.value.replaced is not None:
@@ -240,3 +241,36 @@ class CommunityListGenerator(PartialGenerator, ABC):
                         )
                 else:
                     raise NotImplementedError(f"Community logic {community_list.logic} is not implemented for arista")
+
+    def acl_iosxr(self, _) -> str:
+        return r"""
+        community-set *
+            ~ %global=1
+        extcommunity-set *
+            ~ %global=1
+        """
+
+    def _iosxr_community_list(self, community_list: CommunityList) -> Iterator[Sequence[str]]:
+        if community_list.type is CommunityType.BASIC:
+            name = "community-set"
+        elif community_list.type is CommunityType.RT:
+            name = "extcommunity-set rt"
+        elif community_list.type is CommunityType.SOO:
+            name = "extcommunity-set soo"
+        else:
+            raise NotImplementedError(f"CommunityList type {community_list.type} not implemented for Cisco IOS XR")
+
+        with self.block(name, community_list.name):
+            for n, community in enumerate(community_list.members):
+                if n + 1 < len(community_list.members):
+                    comma = ","
+                else:
+                    comma = ""
+                if community_list.use_regex:
+                    yield "ios-regex", f"'{community}'"
+                else:
+                    yield f"{community}{comma}",
+
+    def run_iosxr(self, device):
+        for community_list in self.get_used_community_lists(device):
+            yield from self._iosxr_community_list(community_list)