annet 0.16.13__py3-none-any.whl → 0.16.15__py3-none-any.whl

annet/adapters/netbox/common/models.py

@@ -139,6 +139,13 @@ class Interface(Entity):
             family = IpFamily(value=6, label="IPv6")
         else:
             family = IpFamily(value=4, label="IPv4")
+
+        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)
+            ):
+                return
         self.ip_addresses.append(IpAddress(
             id=0,
             display=address_mask,

annet/adapters/netbox/common/storage_opts.py

@@ -5,10 +5,11 @@ DEFAULT_URL = "http://localhost"
 
 
 class NetboxStorageOpts:
-    def __init__(self, url: str, token: str, insecure: bool = False):
+    def __init__(self, url: str, token: str, insecure: bool = False, exact_host_filter: bool = False):
         self.url = url
         self.token = token
         self.insecure = insecure
+        self.exact_host_filter = exact_host_filter
 
     @classmethod
     def parse_params(cls, conf_params: Optional[dict[str, str]], cli_opts: Any):
@@ -19,4 +20,8 @@ class NetboxStorageOpts:
             insecure = insecure_env in ("true", "1", "t")
         else:
             insecure = bool(conf_params.get("insecure") or False)
-        return cls(url=url, token=token, insecure=insecure)
+        if exact_host_filter_env := os.getenv("NETBOX_EXACT_HOST_FILTER", "").lower():
+            exact_host_filter = exact_host_filter_env in ("true", "1", "t")
+        else:
+            exact_host_filter = bool(conf_params.get("exact_host_filter") or False)
+        return cls(url=url, token=token, insecure=insecure, exact_host_filter=exact_host_filter)

annet/adapters/netbox/provider.py

@@ -27,10 +27,12 @@ def storage_factory(opts: NetboxStorageOpts) -> Storage:
 
 
 class NetboxProvider(StorageProvider, AdapterWithName, AdapterWithConfig):
-    def __init__(self, url: Optional[str] = None, token: Optional[str] = None, insecure: bool = False):
+    def __init__(self, url: Optional[str] = None, token: Optional[str] = None, insecure: bool = False,
+                 exact_host_filter: bool = False):
         self.url = url
         self.token = token
         self.insecure = insecure
+        self.exact_host_filter = exact_host_filter
 
     @classmethod
     def with_config(cls, **kwargs: Dict[str, Any]) -> T:

annet/adapters/netbox/v37/storage.py

@@ -87,16 +87,19 @@ def extend_ip_address(
 
 class NetboxStorageV37(Storage):
     def __init__(self, opts: Optional[NetboxStorageOpts] = None):
-        ctx: ssl.con | ssl.SSLContext = None
-        if opts.insecure:
-            ctx = ssl.create_default_context()
-            ctx.check_hostname = False
-            ctx.verify_mode = ssl.CERT_NONE
-        self.netbox = NetboxV37(
-            url=opts.url,
-            token=opts.token,
-            ssl_context=ctx,
-        )
+        ctx: Optional[ssl.SSLContext] = None
+        url = ""
+        token = ""
+        self.exact_host_filter = False
+        if opts:
+            if opts.insecure:
+                ctx = ssl.create_default_context()
+                ctx.check_hostname = False
+                ctx.verify_mode = ssl.CERT_NONE
+            url = opts.url
+            token = opts.token
+            self.exact_host_filter = opts.exact_host_filter
+        self.netbox = NetboxV37(url=url, token=token, ssl_context=ctx)
         self._all_fqdns: Optional[list[str]] = None
 
     def __enter__(self):
@@ -147,7 +150,7 @@ class NetboxStorageV37(Storage):
 
         interfaces = self._load_interfaces(list(device_ids))
         neighbours = {x.id: x for x in self._load_neighbours(interfaces)}
-        neighbours_seen = defaultdict(set)
+        neighbours_seen: dict[str, set] = defaultdict(set)
 
         for interface in interfaces:
             device_ids[interface.device.id].interfaces.append(interface)
@@ -162,14 +165,18 @@ class NetboxStorageV37(Storage):
     def _load_devices(self, query: NetboxQuery) -> List[api_models.Device]:
         if not query.globs:
             return []
-        query = _hostname_dot_hack(query)
-        return [
-            device
-            for device in self.netbox.dcim_all_devices(
-                name__ic=query.globs,
-            ).results
-            if _match_query(query, device)
-        ]
+        if self.exact_host_filter:
+            devices = self.netbox.dcim_all_devices(name__ie=query.globs).results
+        else:
+            query = _hostname_dot_hack(query)
+            devices = [
+                device
+                for device in self.netbox.dcim_all_devices(
+                    name__ic=query.globs,
+                ).results
+                if _match_query(query, device)
+            ]
+        return devices
 
     def _extend_interfaces(self, interfaces: List[models.Interface]) -> List[models.Interface]:
         extended_ifaces = {

annet/annlib/netdev/devdb/data/devdb.json

@@ -54,6 +54,8 @@
     "Huawei.CE.CE8800.CE8851": " CE8851",
     "Huawei.CE.CE8800.CE8855": " CE8855",
     "Huawei.CE.CE9800": " CE98\\d\\d",
+    "Huawei.CE.CE9800.CE9855": " CE9855",
+    "Huawei.CE.CE9800.CE9860": " CE9860",
     "Huawei.Quidway": " (LS-)?S",
     "Huawei.Quidway.S2x": "2\\d{3}",
     "Huawei.Quidway.S2x.S2300": "23\\d\\d",

annet/bgp_models.py

@@ -103,7 +103,7 @@ class PeerOptions:
     af_rib_group: Optional[str] = None
     af_loops: Optional[int] = None
     hold_time: Optional[int] = None
-    listen_network: Optional[bool] = None
+    listen_network: Optional[list[str]] = None
     remove_private: Optional[bool] = None
     as_override: Optional[bool] = None
     aigp: Optional[bool] = None
@@ -158,7 +158,7 @@ class Redistribute:
 @dataclass
 class FamilyOptions:
     family: Family
-    vrf_name: str
+    vrf_name: str = ""
     multipath: int = 0
     global_multipath: int = 0
     aggregate: Aggregate = field(default_factory=Aggregate)
@@ -178,6 +178,7 @@ class FamilyOptions:
 class PeerGroup:
     name: str
     remote_as: ASN = ASN(None)
+    families: set[Family] = field(default_factory=set)
     internal_name: str = ""
     description: str = ""
     update_source: str = ""
@@ -213,7 +214,7 @@ class PeerGroup:
     af_rib_group: Optional[str] = None
     af_loops: int = 0
     hold_time: int = 0
-    listen_network: bool = False
+    listen_network: list[str] = field(default_factory=list)
     remove_private: bool = False
     as_override: bool = False
     aigp: bool = False
@@ -234,6 +235,12 @@ class PeerGroup:
 @dataclass
 class VrfOptions:
     vrf_name: str
+
+    ipv4_unicast: FamilyOptions
+    ipv6_unicast: FamilyOptions
+    ipv4_labeled_unicast: FamilyOptions
+    ipv6_labeled_unicast: FamilyOptions
+
     vrf_name_global: Optional[str] = None
     import_policy: Optional[str] = None
     export_policy: Optional[str] = None
@@ -244,23 +251,20 @@ class VrfOptions:
     route_distinguisher: Optional[str] = None
     static_label: Optional[int] = None  # FIXME: str?
 
-    ipv4_unicast: Optional[FamilyOptions] = None
-    ipv6_unicast: Optional[FamilyOptions] = None
-    ipv4_labeled_unicast: Optional[FamilyOptions] = None
-    ipv6_labeled_unicast: Optional[FamilyOptions] = None
     groups: list[PeerGroup] = field(default_factory=list)
 
 
 @dataclass
 class GlobalOptions:
+    ipv4_unicast: FamilyOptions
+    ipv6_unicast: FamilyOptions
+    ipv4_labeled_unicast: FamilyOptions
+    ipv6_labeled_unicast: FamilyOptions
+
     local_as: ASN = ASN(None)
     loops: int = 0
     multipath: int = 0
     router_id: str = ""
     vrf: dict[str, VrfOptions] = field(default_factory=dict)
 
-    ipv4_unicast: Optional[FamilyOptions] = None
-    ipv6_unicast: Optional[FamilyOptions] = None
-    ipv4_labeled_unicast: Optional[FamilyOptions] = None
-    ipv6_labeled_unicast: Optional[FamilyOptions] = None
     groups: list[PeerGroup] = field(default_factory=list)

annet/implicit.py

@@ -71,14 +71,14 @@ def _implicit_tree(device):
                 netconf
             """
     elif device.hw.Arista:
-        # эта часть конфигурации будет не видна в конфиге, если она включена с таким набором полей:
+        # This part of configuration will not be visible in configuration
         text = r"""
                 ip load-sharing trident fields ipv6 destination-port source-ip ingress-interface destination-ip source-port flow-label
                 ip load-sharing trident fields ip source-ip source-port destination-ip destination-port ingress-interface
         """
     elif device.hw.Nexus:
         text = r"""
-                # часть конфигурации скрытая если включена
+                # This part of configuration will not be visible in configuration if enabled
                 snmp-server enable traps link linkDown
                 snmp-server enable traps link linkUp
         """
@@ -107,25 +107,24 @@ def _implicit_tree(device):
             """
 
         elif device.hw.Nexus.N3x:
-            # У нексуса сложные взаимоотношения с
-            # shutdown командой вездe
-            # в данный момент поведение проверенно для Cisco Nexus 3132Q 6.0(2)U6(7)
+            # Cisco Nexus has some specific related to "shutdown" command
+            # Behavior is cheked on Cisco Nexus 3132Q 6.0(2)U6(7)
             text += r"""
                 # SVI
                 !interface Vlan*
                     !shutdown
                 !interface mgmt[0-9]*
                     no shutdown
-                # Физические НЕ сплитованные интерфейсы и subif'ы
+                # Physical and NOT splitted interfaces and subifs
                 !interface */Ethernet1\/[0-9.]*/
                     no shutdown
-                # Физические НЕ сплитованные интерфейсы и subif'ы
+                # Physical and NOT splitted interfaces and subifs
                 !interface */Ethernet1\/[0-9]+\/[0-9.]+/
                     # только explicit
-                # Лупбеки
+                # Loopbacks
                 !interface */Loopback[0-9.]+/
                     no shutdown
-                # Агрегаты
+                # Port-Channels
                 !interface */port-channel[0-9.]+/
                     no shutdown
                 # BGP
@@ -135,7 +134,14 @@ def _implicit_tree(device):
             """
     elif device.hw.Cisco:
         text += r"""
-            !interface
+            !interface */\S*Ethernet\S+/
+                mtu 1500
+                no shutdown
+            !interface */Loopback[0-9.]+/
+                mtu 1500
+                no shutdown
+            !interface */port-channel[0-9.]+/
+                mtu 1500
                 no shutdown
         """
         if device.hw.Cisco.Catalyst:

annet/mesh/__init__.py

@@ -8,9 +8,12 @@ __all__ = [
     "Left",
     "Right",
     "Match",
+    "VirtualLocal",
+    "VirtualPeer",
 ]
 
 from .executor import MeshExecutor
 from .match_args import Left, Right, Match
-from .registry import DirectPeer, IndirectPeer, MeshSession, GlobalOptions
-from .registry import MeshRulesRegistry
+from .registry import (
+    DirectPeer, IndirectPeer, MeshSession, GlobalOptions, MeshRulesRegistry, VirtualLocal, VirtualPeer,
+)

annet/mesh/device_models.py

@@ -1,16 +1,30 @@
 from typing import Annotated, Optional, Union
 
-from annet.bgp_models import Family, Aggregate, Redistribute
+from annet.bgp_models import Family, Redistribute
 from .basemodel import BaseMeshModel, Concat, DictMerge, Merge, KeyDefaultDict
 from .peer_models import MeshPeerGroup
 
 
+class Aggregate(BaseMeshModel):
+    policy: str
+    routes: Annotated[tuple[str, ...], Concat()]
+    export_policy: str
+    as_path: str
+    reference: str
+    suppress: bool
+    discard: bool
+    as_set: bool
+
+
 class FamilyOptions(BaseMeshModel):
+    def __init__(self, **kwargs):
+        kwargs.setdefault("aggregate", Aggregate())
+        super().__init__(**kwargs)
     family: Family
     vrf_name: str
     multipath: int = 0
     global_multipath: int
-    aggregate: Aggregate
+    aggregate: Annotated[Aggregate, Merge()]
     redistributes: Annotated[tuple[Redistribute, ...], Concat()]
     allow_default: bool
     aspath_relax: bool
@@ -24,16 +38,26 @@ class FamilyOptions(BaseMeshModel):
 
 
 class _FamiliesMixin:
-    ipv4_unicast: Optional[FamilyOptions]
-    ipv6_unicast: Optional[FamilyOptions]
-    ipv4_labeled_unicast: Optional[FamilyOptions]
-    ipv6_labeled_unicast: Optional[FamilyOptions]
+    def __init__(self, **kwargs):
+        kwargs.setdefault("ipv4_unicast", FamilyOptions(family="ipv4_unicast"))
+        kwargs.setdefault("ipv6_unicast", FamilyOptions(family="ipv6_unicast"))
+        kwargs.setdefault("ipv4_labeled_unicast", FamilyOptions(family="ipv4_labeled"))
+        kwargs.setdefault("ipv6_labeled_unicast", FamilyOptions(family="ipv6_labeled"))
+        super().__init__(**kwargs)
+    ipv4_unicast: Annotated[FamilyOptions, Merge()]
+    ipv6_unicast: Annotated[FamilyOptions, Merge()]
+    ipv4_labeled_unicast: Annotated[FamilyOptions, Merge()]
+    ipv6_labeled_unicast: Annotated[FamilyOptions, Merge()]
 
 
-class VrfOptions(BaseMeshModel, _FamiliesMixin):
-    def __init__(self, **kwargs):
+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_labeled_unicast", FamilyOptions(family="ipv4_labeled", vrf_name=vrf_name))
+        kwargs.setdefault("ipv6_labeled_unicast", FamilyOptions(family="ipv6_labeled", vrf_name=vrf_name))
         kwargs.setdefault("groups", KeyDefaultDict(lambda x: MeshPeerGroup(name=x)))
-        super().__init__(**kwargs)
+        super().__init__(vrf_name=vrf_name, **kwargs)
 
     vrf_name: str
     vrf_name_global: Optional[str]
@@ -48,7 +72,7 @@ class VrfOptions(BaseMeshModel, _FamiliesMixin):
     groups: Annotated[dict[str, MeshPeerGroup], DictMerge(Merge())]
 
 
-class GlobalOptionsDTO(BaseMeshModel, _FamiliesMixin):
+class GlobalOptionsDTO(_FamiliesMixin, BaseMeshModel):
     def __init__(self, **kwargs):
         kwargs.setdefault("groups", KeyDefaultDict(lambda x: MeshPeerGroup(name=x)))
         kwargs.setdefault("vrf", KeyDefaultDict(lambda x: VrfOptions(vrf_name=x)))

annet/mesh/executor.py

@@ -1,15 +1,22 @@
 from dataclasses import dataclass
 from logging import getLogger
-from typing import Annotated, Callable, Optional
+from typing import Annotated, Callable, Optional, Union
 
 from annet.bgp_models import Peer, GlobalOptions
 from annet.storage import Device, Storage
 from .basemodel import merge, BaseMeshModel, Merge, UseLast, MergeForbiddenError
 from .device_models import GlobalOptionsDTO
 from .models_converter import to_bgp_global_options, to_bgp_peer, InterfaceChanges, to_interface_changes
-from .peer_models import PeerDTO
-from .registry import MeshRulesRegistry, GlobalOptions as MeshGlobalOptions, DirectPeer, MeshSession, IndirectPeer
-
+from .peer_models import DirectPeerDTO, IndirectPeerDTO, VirtualLocalDTO, VirtualPeerDTO
+from .registry import (
+    DirectPeer,
+    GlobalOptions as MeshGlobalOptions,
+    IndirectPeer,
+    MeshRulesRegistry,
+    MeshSession,
+    VirtualLocal,
+    VirtualPeer,
+)
 
 logger = getLogger(__name__)
 
@@ -28,11 +35,16 @@ class PeerKey:
 
 
 class Pair(BaseMeshModel):
-    local: Annotated[PeerDTO, Merge()]
-    connected: Annotated[PeerDTO, Merge()]
+    local: Annotated[Union[DirectPeerDTO, IndirectPeerDTO], Merge()]
+    connected: Annotated[Union[DirectPeerDTO, IndirectPeerDTO], Merge()]
     device: Annotated[Device, UseLast()]
 
 
+class VirtualPair(BaseMeshModel):
+    local: Annotated[VirtualLocalDTO, Merge()]
+    connected: Annotated[VirtualPeerDTO, Merge()]
+
+
 class MeshExecutor:
     def __init__(
             self,
@@ -93,14 +105,14 @@ class MeshExecutor:
                 rule.handler(peer_neighbor, peer_device, session)
 
             try:
-                neighbor_dto = merge(PeerDTO(), peer_neighbor, session)
+                neighbor_dto = merge(DirectPeerDTO(), peer_neighbor, session)
             except MergeForbiddenError as e:
                 raise ValueError(
                     f"Handler `{handler_name}` provided session data conflicting with "
                     f"peer data for device `{neighbor_device.fqdn}`:\n" + str(e)
                 ) from e
             try:
-                device_dto = merge(PeerDTO(), peer_device, session)
+                device_dto = merge(DirectPeerDTO(), peer_device, session)
             except MergeForbiddenError as e:
                 raise ValueError(
                     f"Handler `{handler_name}` provided session data conflicting with "
@@ -132,6 +144,42 @@ class MeshExecutor:
             neighbor_peers[peer_key] = pair
         return list(neighbor_peers.values())
 
+    def _execute_virtual(self, device: Device) -> list[VirtualPair]:
+        virtual_peers: list[VirtualPair] = []
+        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)
+                session = MeshSession()
+                peer_device = VirtualLocal(rule.match, device)
+                peer_virtual = VirtualPeer(num=order_number)
+
+                rule.handler(peer_device, peer_virtual, session)
+
+                try:
+                    virtual_dto = merge(VirtualPeerDTO(), peer_virtual, session)
+                except MergeForbiddenError as e:
+                    raise ValueError(
+                        f"Handler `{handler_name}` provided session data conflicting with "
+                        f"virtual peer data for device `{device.fqdn}` and num={order_number}:\n" + str(e)
+                    ) from e
+                try:
+                    device_dto = merge(VirtualLocalDTO(), peer_device, session)
+                except MergeForbiddenError as e:
+                    raise ValueError(
+                        f"Handler `{handler_name}` provided session data conflicting with "
+                        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
+
     def _execute_indirect(self, device: Device, all_fqdns: list[str]) -> list[Pair]:
         # we can have multiple rules for the same pair
         # we merge them according to remote fqdn
@@ -152,14 +200,14 @@ class MeshExecutor:
                 rule.handler(peer_connected, peer_device, session)
 
             try:
-                connected_dto = merge(PeerDTO(), peer_connected, session)
+                connected_dto = merge(IndirectPeerDTO(), peer_connected, session)
             except MergeForbiddenError as e:
                 raise ValueError(
                     f"Handler `{handler_name}` provided session data conflicting with "
                     f"peer data for device `{connected_device.fqdn}`:\n" + str(e)
                 ) from e
             try:
-                device_dto = merge(PeerDTO(), peer_device, session)
+                device_dto = merge(IndirectPeerDTO(), peer_device, session)
             except MergeForbiddenError as e:
                 raise ValueError(
                     f"Handler `{handler_name}` provided session data conflicting with "
@@ -193,7 +241,10 @@ class MeshExecutor:
         return list(connected_peers.values())  # FIXME
 
     def _to_bgp_peer(self, pair: Pair, interface: Optional[str]) -> Peer:
-        return to_bgp_peer(pair.local, pair.connected, pair.device, interface)
+        return to_bgp_peer(pair.local, pair.connected, pair.device.hostname, interface)
+
+    def _virtual_to_bgp_peer(self, pair: VirtualPair, interface: Optional[str]) -> Peer:
+        return to_bgp_peer(pair.local, pair.connected, "", interface)
 
     def _to_bgp_global(self, global_options: GlobalOptionsDTO) -> GlobalOptions:
         return to_bgp_global_options(global_options)
@@ -225,6 +276,9 @@ 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) -> MeshExecutionResult:
         all_fqdns = self._storage.resolve_all_fdnds()
 
@@ -239,6 +293,13 @@ class MeshExecutor:
             )
             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(
+                device,
+                virtual_pair.local,
+            )
+            peers.append(self._virtual_to_bgp_peer(virtual_pair, target_interface))
+
         for connected_pair in self._execute_indirect(device, all_fqdns):
             peers.append(self._to_bgp_peer(connected_pair, None))
 

annet/mesh/models_converter.py

@@ -1,12 +1,18 @@
 from dataclasses import dataclass
 from ipaddress import ip_interface
-from typing import Optional
+from typing import Optional, Union
 
-from adaptix import Retort, loader, Chain, name_mapping
+from adaptix import Retort, loader, Chain, name_mapping, as_is_loader
 
-from .peer_models import PeerDTO
-from ..bgp_models import GlobalOptions, VrfOptions, FamilyOptions, Peer, PeerGroup, ASN, PeerOptions
-from ..storage import Device
+from .peer_models import DirectPeerDTO, IndirectPeerDTO, VirtualPeerDTO, VirtualLocalDTO
+from ..bgp_models import (
+    Aggregate, GlobalOptions, VrfOptions, FamilyOptions, Peer, PeerGroup, ASN, PeerOptions,
+    Redistribute, BFDTimers,
+)
+
+
+PeerDTO = Union[DirectPeerDTO, IndirectPeerDTO, VirtualPeerDTO]
+LocalDTO = Union[DirectPeerDTO, IndirectPeerDTO, VirtualLocalDTO]
 
 
 @dataclass
@@ -46,7 +52,10 @@ retort = Retort(
         loader(GlobalOptions, ObjMapping, Chain.FIRST),
         loader(VrfOptions, ObjMapping, Chain.FIRST),
         loader(FamilyOptions, ObjMapping, Chain.FIRST),
+        loader(Aggregate, ObjMapping, Chain.FIRST),
         loader(PeerOptions, ObjMapping, Chain.FIRST),
+        as_is_loader(Redistribute),
+        as_is_loader(BFDTimers),
         name_mapping(PeerOptions, map={
             "local_as": "asnum",
         }),
@@ -62,14 +71,13 @@ to_bgp_global_options = retort.get_loader(GlobalOptions)
 to_interface_changes = retort.get_loader(InterfaceChanges)
 
 
-def to_bgp_peer(local: PeerDTO, connected: PeerDTO, connected_device: Device, interface: Optional[str]) -> Peer:
+def to_bgp_peer(local: LocalDTO, connected: PeerDTO, connected_hostname: str, interface: Optional[str]) -> Peer:
     options = retort.load(local, PeerOptions)
-    # TODO validate `lagg_links` before conversion
     result = Peer(
         addr=str(ip_interface(connected.addr).ip),
         interface=interface,
         remote_as=ASN(connected.asnum),
-        hostname=connected_device.hostname,
+        hostname=connected_hostname,
         options=options,
     )
     # connected
@@ -78,7 +86,7 @@ def to_bgp_peer(local: PeerDTO, connected: PeerDTO, connected_device: Device, in
     result.description = getattr(connected, "description", result.description)
     result.families = getattr(connected, "families", result.families)
     # local
-    result.import_policy = getattr(connected, "import_policy", result.import_policy)
-    result.export_policy = getattr(connected, "export_policy", result.export_policy)
-    result.update_source = getattr(connected, "update_source", result.update_source)
+    result.import_policy = getattr(local, "import_policy", result.import_policy)
+    result.export_policy = getattr(local, "export_policy", result.export_policy)
+    result.update_source = getattr(local, "update_source", result.update_source)
     return result

annet/mesh/peer_models.py

@@ -61,7 +61,7 @@ class _OptionsDTO(_SharedOptionsDTO):
     af_rib_group: Optional[str]
     af_loops: int
     hold_time: int
-    listen_network: bool
+    listen_network: list[str]
     remove_private: bool
     as_override: bool
     aigp: bool
@@ -77,21 +77,46 @@ class _OptionsDTO(_SharedOptionsDTO):
     mtu: int
 
 
-class PeerDTO(MeshSession, _OptionsDTO):
+class DirectPeerDTO(MeshSession, _OptionsDTO):
     pod: int
     addr: str
     description: str
+    update_source: str
 
     subif: int
     lag: Optional[int]
     lag_links_min: Optional[int]
     svi: Optional[int]
 
-    group_name: str
+
+class IndirectPeerDTO(MeshSession, _OptionsDTO):
+    pod: int
+    addr: str
+    description: str
+    update_source: str
+
+
+class VirtualLocalDTO(_OptionsDTO):
+    asnum: int
+    pod: int
+    addr: str
+    description: str
+
+    import_policy: str
+    export_policy: str
+    update_source: str
+
+    svi: int
+
+
+class VirtualPeerDTO(MeshSession):
+    addr: str
+    description: str
 
 
 class MeshPeerGroup(_OptionsDTO):
     name: str
+    families: Annotated[set[FamilyName], Concat()]
     remote_as: Union[int, str]
     internal_name: str
     update_source: str

annet/mesh/registry.py

@@ -1,13 +1,13 @@
 from dataclasses import dataclass
-from typing import Callable, Any
+from typing import Callable, Any, Sequence
 
 from .match_args import MatchExpr, PairMatcher, SingleMatcher
 from .match_args import MatchedArgs
 from .device_models import GlobalOptionsDTO
-from .peer_models import PeerDTO, MeshSession
+from .peer_models import MeshSession, IndirectPeerDTO, VirtualLocalDTO, VirtualPeerDTO, DirectPeerDTO
 
 
-class DirectPeer(PeerDTO):
+class DirectPeer(DirectPeerDTO):
     match: MatchedArgs
     device: Any
     ports: list[str]
@@ -19,7 +19,7 @@ class DirectPeer(PeerDTO):
         self.ports = ports
 
 
-class IndirectPeer(PeerDTO):
+class IndirectPeer(IndirectPeerDTO):
     match: MatchedArgs
     device: Any
 
@@ -29,6 +29,20 @@ class IndirectPeer(PeerDTO):
         self.device = device
 
 
+class VirtualLocal(VirtualLocalDTO):
+    match: MatchedArgs
+    device: Any
+
+    def __init__(self, match: MatchedArgs, device: Any) -> None:
+        super().__init__()
+        self.match = match
+        self.device = device
+
+
+class VirtualPeer(VirtualPeerDTO):
+    num: int
+
+
 class GlobalOptions(GlobalOptionsDTO):
     match: MatchedArgs
     device: Any
@@ -50,6 +64,7 @@ class GlobalRule:
 
 DirectHandler = Callable[[DirectPeer, DirectPeer, MeshSession], None]
 IndirectHandler = Callable[[IndirectPeer, IndirectPeer, MeshSession], None]
+VirtualHandler = Callable[[VirtualLocal, VirtualPeer, MeshSession], None]
 
 
 @dataclass
@@ -66,6 +81,14 @@ class IndirectRule:
     handler: IndirectHandler
 
 
+@dataclass
+class VirtualRule:
+    __slots__ = ("matcher", "num", "handler")
+    matcher: SingleMatcher
+    num: Sequence[int]
+    handler: VirtualHandler
+
+
 @dataclass
 class MatchedGlobal:
     __slots__ = ("match", "handler")
@@ -95,11 +118,20 @@ class MatchedIndirectPair:
     match_right: MatchedArgs
 
 
+@dataclass
+class MatchedVirtualPair:
+    __slots__ = ("match", "num", "handler")
+    match: MatchedArgs
+    num: Sequence[int]
+    handler: VirtualHandler
+
+
 class MeshRulesRegistry:
     def __init__(self, match_short_name: bool = False):
         self.direct_rules: list[DirectRule] = []
         self.indirect_rules: list[IndirectRule] = []
         self.global_rules: list[GlobalRule] = []
+        self.virtual_rules: list[VirtualRule] = []
         self.nested: list[MeshRulesRegistry] = []
         self.match_short_name = match_short_name
 
@@ -142,6 +174,17 @@ class MeshRulesRegistry:
 
         return register
 
+    def virtual(
+            self, peer_mask: str, num: Sequence[int], *match: MatchExpr,
+    ) -> Callable[[VirtualHandler], VirtualHandler]:
+        matcher = SingleMatcher(peer_mask, match)
+
+        def register(handler: VirtualHandler) -> VirtualHandler:
+            self.virtual_rules.append(VirtualRule(matcher, num, handler))
+            return handler
+
+        return register
+
     def lookup_direct(self, device: str, neighbors: list[str]) -> list[MatchedDirectPair]:
         found = []
         device = self._normalize_host(device)
@@ -198,6 +241,20 @@ class MeshRulesRegistry:
             found.extend(registry.lookup_indirect(device, devices))
         return found
 
+    def lookup_virtual(self, device: str) -> list[MatchedVirtualPair]:
+        found = []
+        device = self._normalize_host(device)
+        for rule in self.virtual_rules:
+            if args := rule.matcher.match_one(device):
+                found.append(MatchedVirtualPair(
+                    handler=rule.handler,
+                    match=args,
+                    num=rule.num,
+                ))
+        for registry in self.nested:
+            found.extend(registry.lookup_virtual(device))
+        return found
+
     def lookup_global(self, device: str) -> list[MatchedGlobal]:
         found = []
         device = self._normalize_host(device)

{annet-0.16.13.dist-info → annet-0.16.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: annet
-Version: 0.16.13
+Version: 0.16.15
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-0.16.13.dist-info → annet-0.16.15.dist-info}/RECORD

@@ -1,7 +1,7 @@
 annet/__init__.py,sha256=k2dq8aOYjkjZszKoOlxEmR49uYoKh-8_HC2K8FeqLwA,2139
 annet/annet.py,sha256=TMdEuM7GJQ4TjRVmuK3bCTZN-21lxjQ9sXqEdILUuBk,725
 annet/argparse.py,sha256=v1MfhjR0B8qahza0WinmXClpR8UiDFhmwDDWtNroJPA,12855
-annet/bgp_models.py,sha256=lV9TW7oPiaiWxD9c5pMIpAnghVIUFK_cTpxNbUUfIaM,8082
+annet/bgp_models.py,sha256=SUBiOFVK4PCzFO7AjcypF3E9SrvbNx8i7hdUYmLmDMo,8041
 annet/cli.py,sha256=hDpjIr3w47lgQ_CvCQS1SXFDK-SJrf5slbT__5u6GIA,12342
 annet/cli_args.py,sha256=KQlihxSl-Phhq1-9oJDdNSbIllEX55LlPfH6viEKOuw,13483
 annet/connectors.py,sha256=-Lghz3PtWCBU8Ohrp0KKQcmm1AUZtN0EnOaZ6IQgCQI,5105
@@ -11,7 +11,7 @@ annet/executor.py,sha256=Jny-hm0otZA1naPpFWR-R16SbaZioSQ8pkx-Yd2PYlM,19004
 annet/filtering.py,sha256=ZtqxPsKdV9reZoRxtQyBg22BqyMqd-2SotYcxZ-68AQ,903
 annet/gen.py,sha256=rOAveprvBaEXbLyaQUhQ0QtOvcDfndlIOpchNhu8M1U,33499
 annet/hardware.py,sha256=_iR28dWiPtt6ZYdk-qg1sxazkSRJE3ukqKB-fFFfQak,1141
-annet/implicit.py,sha256=1_FdVCMdIM7O1lYVMY9AuHaBp9E6h6Hc5kuog55bCzI,5573
+annet/implicit.py,sha256=kGKO-mdvPw4HROx4VhnQWxbNlnbG2LuSYEzZbQX2Elo,5518
 annet/lib.py,sha256=lOdz3UJFYkO0wnuzIRRq3FpULQliqBtfmGmKOGVFO4Q,4238
 annet/output.py,sha256=FYMcWCc43-b51KsCiKnXPZHawhgWNoVtY9gRqw__Ce0,7473
 annet/parallel.py,sha256=hLkzEht0KhzmzUWDdO4QFYQHzhxs3wPlTA8DxbB2ziw,17160
@@ -29,18 +29,18 @@ annet/adapters/fetchers/stub/fetcher.py,sha256=bJGNJcvjrxSa4d8gly6NkaRcxoK57zbZh
 annet/adapters/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/adapters/file/provider.py,sha256=Wn3sG2TOI6ZWuRHhPSyg8S0Dnrz5LN3VyuqE6S7r5GM,5930
 annet/adapters/netbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-annet/adapters/netbox/provider.py,sha256=cEPdHKw4zWA3Wrfmj01spQrkGpwcQdZ0Jjy51m5mvs4,1542
+annet/adapters/netbox/provider.py,sha256=3IrfZ6CfCxf-lTnJlIC2TQ8M_rDxOB_B7HGXZ92vAgA,1643
 annet/adapters/netbox/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/adapters/netbox/common/client.py,sha256=PaxHG4W9H8_uunIwMBNYkLq4eQJYoO6p6gY-ciQs7Nc,2563
 annet/adapters/netbox/common/manufacturer.py,sha256=QoTjmuBAg5klOJqeo8HuS2HybIUGsjTkknLkQL_Tiec,1606
-annet/adapters/netbox/common/models.py,sha256=SeWQZV-zvaKvK2YT2Bwf-iapkIs5pr7I7rAI7vlFMB8,6886
+annet/adapters/netbox/common/models.py,sha256=JAAtbUB6UOzA3-VF5Fa33XktgKC3C2csareTZnHyqd0,7177
 annet/adapters/netbox/common/query.py,sha256=ziUFM7cUEbEIf3k1szTll4aO-OCUa-2Ogxbebi7Tegs,646
 annet/adapters/netbox/common/status_client.py,sha256=W4nTb2yvBlJ2UkWUmUhKQ2PaSQb1shjhHj5ebb4s2s4,591
-annet/adapters/netbox/common/storage_opts.py,sha256=0xQeO_OGex73cV9UA5XZn7hLiyhGYwNHYtO5JtMSR4o,815
+annet/adapters/netbox/common/storage_opts.py,sha256=5tt6wxUUJTIzNbOVXMnYBwZedNAIqYlve3YWl6GdbZM,1197
 annet/adapters/netbox/v24/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/adapters/netbox/v24/storage.py,sha256=THI592VLx3ehixsPZQ1Ko3mYIAZQbnDY-toIziqBbL8,6005
 annet/adapters/netbox/v37/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-annet/adapters/netbox/v37/storage.py,sha256=nCcQtjrAvi9sW0_XHZDCFnOk1XIbWUO_pRt1m6E0ELk,9957
+annet/adapters/netbox/v37/storage.py,sha256=a_KnjkEQrK6o2pG9-c9xHYGtj05E2F01JZy7_GIUp7g,10330
 annet/annlib/__init__.py,sha256=fT1l4xV5fqqg8HPw9HqmZVN2qwS8i6X1aIm2zGDjxKY,252
 annet/annlib/command.py,sha256=uuBddMQphtn8P5MO5kzIa8_QrtMns-k05VeKv1bcAuA,1043
 annet/annlib/diff.py,sha256=MZ6eQAU3cadQp8KaSE6uAYFtcfMDCIe_eNuVROnYkCk,4496
@@ -55,7 +55,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=aKYjjLbJebdKBjnGDpVLQdSqrV2JL24spGm58tmMWVU,892
-annet/annlib/netdev/devdb/data/devdb.json,sha256=Qph7WxZBEbgBqbCFeYu6ZM0qkEBn80WmJEjfJkcaZ-0,5940
+annet/annlib/netdev/devdb/data/devdb.json,sha256=_apUe1EsJORxD5CfAvBcpPlnIf_H7I_hjLuVTgS5-H0,6024
 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=3JCZLH7deIHhCguwPJTUX-WDvWjG_xt6BdSEZSO6zkQ,4226
@@ -81,14 +81,14 @@ annet/generators/ref.py,sha256=QVdeL8po1D0kBsVLOpCjFR81D8yNTk-kaQj5WUM4hng,438
 annet/generators/result.py,sha256=zMAvGOYQU803bGy6datZduHLgrEqK2Zba_Jcf9Qn9p0,4976
 annet/generators/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/generators/common/initial.py,sha256=qYBxXFhyOPy34cxc6hsIXseod-lYCmmbuNHpM0uteY0,1244
-annet/mesh/__init__.py,sha256=_Ho7ZwPuEZ7wsOu_oG0avvPzQVn8g-A0w2fqZ42Gf30,369
+annet/mesh/__init__.py,sha256=ZVFPnNOBgP42d7dUnCypGh3RKy0Ne_ObWVzROlE1nFA,423
 annet/mesh/basemodel.py,sha256=bBBx1wu3ftENgf_4PGCV-SkEcxH3tFekvoointT3894,4739
-annet/mesh/device_models.py,sha256=m3S2IUW7dH0drAop3imwuTk27X93c8lLC2ot8S6rA5Y,2068
-annet/mesh/executor.py,sha256=KoFrDd-6XsN2IO-AnLKYiKYebMmN6KpbUVq8AWXUYVE,10926
+annet/mesh/device_models.py,sha256=Jv6g9blnvTVxHGgHhnGd3b_8C3EHGpV7txyyR0Yt_Rg,3301
+annet/mesh/executor.py,sha256=iDarSYfq9H6MSf-M1HkQOFIaUb8j-nG0sQNbgzq4XIo,13726
 annet/mesh/match_args.py,sha256=CR3kdIV9NGtyk9E2JbcOQ3TRuYEryTWP3m2yCo2VCWg,5751
-annet/mesh/models_converter.py,sha256=EdAQIkE-AfdCqMuzVQEdsG5lQdsaAwmqNqq9b8GRnGQ,2888
-annet/mesh/peer_models.py,sha256=sHny5nvLTWY2gqrq-SzZJ-lzEa90E_RCuBoiLb-Rub8,2129
-annet/mesh/registry.py,sha256=N2QyfyH0Qt73l16CO8VRKIBKHscBntEfS-j9B4xs-ys,6906
+annet/mesh/models_converter.py,sha256=9K-B-Y5gQktr6ycHiCIM0OHsCM8yPUpO89AceU0Of3A,3168
+annet/mesh/peer_models.py,sha256=T8sgKcg1a0BAkRVS5Kfc65CrlIB2AqQcwrehfEqWhLk,2572
+annet/mesh/registry.py,sha256=G-FszWc_VKeN3eVpb-MRGbAGzbcSuEVAzbDC2k747XA,8611
 annet/rulebook/__init__.py,sha256=14IpOfTbeJtre7JKrfXVYiH0qAXsUSOL7AatUFmSQs0,3847
 annet/rulebook/common.py,sha256=zK1s2c5lc5HQbIlMUQ4HARQudXSgOYiZ_Sxc2I_tHqg,721
 annet/rulebook/deploying.py,sha256=XV0XQvc3YvwM8SOgOQlc-fCW4bnjQg_1CTZkTwMp14A,2972
@@ -150,12 +150,12 @@ annet_generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 annet_generators/example/__init__.py,sha256=1z030I00c9KeqW0ntkT1IRLYKD5LZAHYjiNHrOLen1Q,221
 annet_generators/example/lldp.py,sha256=24bGvShxbio-JxUdaehyPRu31LhH9YwSwFDrWVRn6yo,2100
 annet_generators/mesh_example/__init__.py,sha256=NfNWgXn1TNiWI6A5tmU6Y-4QV2i33td0Qs3re0MNNMo,218
-annet_generators/mesh_example/bgp.py,sha256=ck--yU_lUdAX9DWaaVQ-C29eQN-EGf1gEpOTBxmMnWA,1317
-annet_generators/mesh_example/mesh_logic.py,sha256=5Wt17LPt-EWe126IFAdaQQGWIOR3mxTJjAMUY8K0c0w,971
-annet-0.16.13.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
-annet-0.16.13.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
-annet-0.16.13.dist-info/METADATA,sha256=cl7oaJlf7U2dc3ZZuRFwguqPK0XWbPaoLjdNmP52Mek,745
-annet-0.16.13.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
-annet-0.16.13.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
-annet-0.16.13.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
-annet-0.16.13.dist-info/RECORD,,
+annet_generators/mesh_example/bgp.py,sha256=jzyDndSSGYyYBquDnLlR-7P5lzmUKcSyYCml3VsoMC0,1385
+annet_generators/mesh_example/mesh_logic.py,sha256=DJS5JMCTs0rs0LN__0LulNgo2ekUcWiOMe02BlOeFas,1454
+annet-0.16.15.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
+annet-0.16.15.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
+annet-0.16.15.dist-info/METADATA,sha256=VI-njmyEaLFgh_aLn0WYEXAxnsims000_VWqTUu5ujc,745
+annet-0.16.15.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+annet-0.16.15.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
+annet-0.16.15.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
+annet-0.16.15.dist-info/RECORD,,

{annet-0.16.13.dist-info → annet-0.16.15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.4.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

annet_generators/mesh_example/bgp.py

@@ -21,6 +21,7 @@ class Bgp(PartialGenerator):
         res = executor.execute_for(device)
         yield f"bgp {res.global_options.local_as}"
         for peer in res.peers:
+            yield f"   peer {peer.addr} interface {peer.interface}"
             if peer.group_name:
                 yield f"   peer {peer.addr} {peer.group_name}"
             if peer.remote_as is not None:

annet_generators/mesh_example/mesh_logic.py

@@ -1,4 +1,5 @@
-from annet.mesh import Right, MeshRulesRegistry, GlobalOptions, MeshSession, DirectPeer
+from annet.bgp_models import Redistribute, BFDTimers
+from annet.mesh import Right, MeshRulesRegistry, GlobalOptions, MeshSession, DirectPeer, VirtualLocal, VirtualPeer
 
 registry = MeshRulesRegistry()
 
@@ -6,6 +7,9 @@ registry = MeshRulesRegistry()
 @registry.device("{name:.*}")
 def device_handler(global_opts: GlobalOptions):
     global_opts.local_as = 12345
+    global_opts.ipv4_unicast.redistributes = (Redistribute(
+        protocol="ipv4", policy="sss",
+    ),)
     global_opts.groups["GROP_NAME"].remote_as = 11111
 
 
@@ -16,6 +20,15 @@ def direct_handler(device: DirectPeer, neighbor: DirectPeer, session: MeshSessio
     neighbor.addr = f"192.168.1.{neighbor.match.x}"
 
 
+@registry.virtual("{name:.*}", num=[1, 2, 3])
+def virtual_handler(device: VirtualLocal, peer: VirtualPeer, session: MeshSession):
+    session.asnum = 12345
+    device.svi = 1
+    device.addr = "192.168.1.254"
+    device.listen_network = ["10.0.0.0/8"]
+    peer.addr = f"192.168.127.{peer.num}"
+
+
 @registry.direct("{name:.*}", "m9-sgw{x}.{domain:.*}", Right.x.in_([0, 1]))
 def direct_handler2(device: DirectPeer, neighbor: DirectPeer, session: MeshSession):
     session.asnum = 12345