annet 0.16.17__py3-none-any.whl → 0.16.19__py3-none-any.whl

annet/adapters/netbox/common/manufacturer.py

@@ -17,7 +17,8 @@ _VENDORS = {
     "aruba": "Aruba",
     "routeros": "RouterOS",
     "ribbon": "Ribbon",
-    "b4com": "B4com"
+    "b4com": "B4com",
+    "h3c": "H3C",
 }
 
 
@@ -37,6 +38,8 @@ def get_breed(manufacturer: str, model: str):
         return "vrp85"
     elif manufacturer == "Huawei":
         return "vrp55"
+    elif manufacturer == "H3C":
+        return "h3c"
     elif manufacturer in ("Mellanox", "NVIDIA"):
         return "cuml2"
     elif manufacturer == "Juniper":

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

@@ -53,6 +53,7 @@
     "Huawei.CE.CE8800.CE8850": " CE8850",
     "Huawei.CE.CE8800.CE8851": " CE8851",
     "Huawei.CE.CE8800.CE8855": " CE8855",
+    "Huawei.CE.CE8800.CE8875": " CE8875",
     "Huawei.CE.CE9800": " CE98\\d\\d",
     "Huawei.CE.CE9800.CE9855": " CE9855",
     "Huawei.CE.CE9800.CE9860": " CE9860",

annet/annlib/rbparser/platform.py

@@ -1,5 +1,6 @@
 VENDOR_REVERSES = {
     "huawei": "undo",
+    "h3c": "undo",
     "optixtrans": "undo",
     "cisco": "no",
     "nexus": "no",
@@ -45,6 +46,7 @@ VENDOR_DIFF_ORDERED = {
 
 VENDOR_EXIT = {
     "huawei": "quit",
+    "h3c": "quit",
     "optixtrans": "quit",
     "cisco": "exit",
     "nexus": "exit",
@@ -57,3 +59,7 @@ VENDOR_EXIT = {
     "ribbon": "exit",
     "b4com": "exit",
 }
+
+VENDOR_ALIASES = {
+    "h3c": "huawei",
+}

annet/annlib/rulebook/common.py

@@ -356,6 +356,10 @@ def apply(hw, do_commit, do_finalize, **_):
             after.add_cmd(Command("commit"))
         if do_finalize:
             after.add_cmd(Command("write", timeout=40))
+    elif hw.H3C:
+        before.add_cmd(Command("system-view"))
+        if do_finalize:
+            after.add_cmd(Command("save force", timeout=20))
     else:
         raise Exception("unknown hw %s" % hw)
 

annet/annlib/tabparser.py

@@ -2,7 +2,7 @@ import dataclasses
 import itertools
 import re
 from collections import OrderedDict as odict
-from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Tuple, Union, List
 
 from .types import Op
 
@@ -271,8 +271,63 @@ class CiscoFormatter(BlockExitFormatter):
     def __init__(self, indent="  "):
         super().__init__("exit", indent)
 
+    def _split_indent(
+        self, line: str, indent: int, block_exit_strings: List[str]
+    ) -> Tuple[List[str], int]:
+        """
+        The small helper calculates indent shift based on block exit string.
+        If configuration line has non-default block exit string it means that
+        new subsection is started and indent should be increased.
+        If configuration line exists in list of block exit strings,
+        it means that subsection is finished and indent should be decreased
+
+        Args:
+            line: just configuration line
+            indent: current indent
+            block_exit_strings: list of previously seen block exit strings
+        Returns:
+            new indent and list of previously seen block exit strings
+        """
+
+        if line.strip() in block_exit_strings:
+            indent -= 1
+            block_exit_strings.remove(line.strip())
+            return block_exit_strings, indent
+
+        block_exit_wrapped = [
+            v for v in self.block_exit(FormatterContext(current=(line.strip(), {})))
+        ]
+
+        if not block_exit_wrapped or len(block_exit_wrapped) != 3:
+            return block_exit_strings, indent
+        if not isinstance(block_exit_wrapped[1], str):
+            return block_exit_strings, indent
+        if block_exit_wrapped[1] == self._block_exit:
+            return block_exit_strings, indent
+
+        indent += 1
+        block_exit_strings.append(block_exit_wrapped[1])
+        return block_exit_strings, indent
+
     def split(self, text):
-        return self.split_remove_spaces(text)
+        additional_indent = 0
+        block_exit_strings = [self._block_exit]
+        tree = self.split_remove_spaces(text)
+        for i, item in enumerate(tree):
+            block_exit_strings, new_indent = self._split_indent(
+                item, additional_indent, block_exit_strings
+            )
+            tree[i] = f"{' ' * additional_indent}{item}"
+            additional_indent = new_indent
+        return tree
+
+    def block_exit(self, context: Optional[FormatterContext]) -> str:
+        current = context and context.row or ""
+
+        if current.startswith(("address-family")):
+            yield from block_wrapper("exit-address-family")
+        else:
+            yield from super().block_exit(context)
 
 
 class AsrFormatter(BlockExitFormatter):

annet/configs/context.yml

@@ -2,6 +2,7 @@ generators:
   default:
     - annet_generators.example
     - annet_generators.mesh_example
+    - annet_generators.rpl_example
 
 storage:
   default:

annet/rpl/__init__.py

@@ -0,0 +1,27 @@
+__all__ = [
+    "MatchField",
+    "ThenField",
+    "RouteMap",
+    "Route",
+    "ResultType",
+    "ActionType",
+    "Action",
+    "SingleAction",
+    "AndCondition",
+    "R",
+    "ConditionOperator",
+    "Condition",
+    "SingleCondition",
+    "RoutingPolicyStatement",
+    "RoutingPolicy",
+    "CommunityActionValue",
+    "PrefixMatchValue",
+]
+
+from .action import Action, ActionType, SingleAction
+from .condition import AndCondition, Condition, ConditionOperator, SingleCondition
+from .match_builder import R, MatchField, PrefixMatchValue
+from .policy import RoutingPolicyStatement, RoutingPolicy
+from .result import ResultType
+from .routemap import RouteMap, Route
+from .statement_builder import ThenField, CommunityActionValue

annet/rpl/action.py

@@ -0,0 +1,51 @@
+from collections.abc import Iterator, Iterable
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, TypeVar, Any
+
+
+class ActionType(Enum):
+    SET = "set"
+    ADD = "add"
+    REMOVE = "delete"
+
+    CUSTOM = "custom"
+
+
+ValueT = TypeVar("ValueT")
+
+
+@dataclass
+class SingleAction(Generic[ValueT]):
+    field: str
+    type: ActionType
+    value: ValueT
+
+
+class Action:
+    def __init__(self) -> None:
+        self.actions: list[SingleAction[Any]] = []
+
+    def append(self, action: SingleAction[Any]) -> None:
+        self.actions.append(action)
+
+    def __repr__(self):
+        actions = ", ".join(repr(c) for c in self.actions)
+        return f"Action({actions})"
+
+    def __getitem__(self, item: str) -> SingleAction[Any]:
+        return next(c for c in self.actions if c.field == item)
+
+    def __contains__(self, item: str) -> bool:
+        return any(c.field == item for c in self.actions)
+
+    def __len__(self) -> int:
+        return len(self.actions)
+
+    def __iter__(self) -> Iterator[SingleAction[Any]]:
+        return iter(self.actions)
+
+    def find_all(self, item: str) -> Iterable[SingleAction[Any]]:
+        for action in self.actions:
+            if action.field == item:
+                yield action

annet/rpl/condition.py

@@ -0,0 +1,94 @@
+from collections.abc import Iterator, Iterable
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, TypeVar, Sequence, Union, Any
+
+
+class ConditionOperator(Enum):
+    EQ = "=="
+    GE = ">="
+    GT = ">"
+    LE = "<="
+    LT = "<"
+    BETWEEN_INCLUDED = "BETWEEN_INCLUDED"
+
+    HAS = "has"
+    HAS_ANY = "has_any"
+
+    CUSTOM = "custom"
+
+
+ValueT = TypeVar("ValueT")
+
+
+@dataclass(frozen=True)
+class SingleCondition(Generic[ValueT]):
+    field: str
+    operator: ConditionOperator
+    value: ValueT
+
+    def __and__(self, other: "Condition") -> "Condition":
+        return AndCondition(self, other)
+
+    def merge(self, other: "SingleCondition[Any]") -> "SingleCondition[Any]":
+        if other.field != self.field:
+            raise ValueError(f"Cannot merge conditions with different fields: {self.field} != {other.field}")
+        if self.operator is ConditionOperator.LE:
+            if other.operator is ConditionOperator.GE:
+                return SingleCondition(self.field, ConditionOperator.BETWEEN_INCLUDED, (other.value, self.value))
+            elif other.operator is ConditionOperator.LE:
+                return SingleCondition(self.field, ConditionOperator.LE, min(self.value, other.value))
+        elif self.operator is ConditionOperator.GE:
+            if other.operator is ConditionOperator.LE:
+                return other.merge(self)
+            elif other.operator is ConditionOperator.GE:
+                return SingleCondition(self.field, ConditionOperator.GE, max(self.value, other.value))
+        elif self.operator is ConditionOperator.LT:
+            if other.operator is ConditionOperator.LT:
+                return SingleCondition(self.field, ConditionOperator.LT, min(self.value, other.value))
+        elif self.operator is ConditionOperator.GT:
+            if other.operator is ConditionOperator.GT:
+                return SingleCondition(self.field, ConditionOperator.GT, max(self.value, other.value))
+        raise ValueError(f"Cannot merge condition with operator {self.operator} and {other.operator}")
+
+
+Condition = Union[SingleCondition, "AndCondition"]
+
+
+class AndCondition:
+    def __init__(self, *conditions: Condition):
+        self.conditions: list[SingleCondition[Any]] = []
+        for c in conditions:
+            self.conditions.extend(self._unpack(c))
+
+    def _unpack(self, other: Condition) -> Sequence[SingleCondition]:
+        if isinstance(other, AndCondition):
+            return other.conditions
+        return [other]
+
+    def __and__(self, other: Condition) -> "AndCondition":
+        return AndCondition(*self.conditions, other)
+
+    def __iadd__(self, other):
+        self.conditions.extend(self._unpack(other))
+
+    def __repr__(self):
+        conditions = ", ".join(repr(c) for c in self.conditions)
+        return f"AndCondition({conditions})"
+
+    def __getitem__(self, item: str) -> SingleCondition[Any]:
+        return next(c for c in self.conditions if c.field == item)
+
+    def __contains__(self, item: str) -> bool:
+        return any(c.field == item for c in self.conditions)
+
+    def __len__(self) -> int:
+        return len(self.conditions)
+
+    def __iter__(self) -> Iterator[SingleCondition[Any]]:
+        return iter(self.conditions)
+
+    def find_all(self, item: str) -> Iterable[SingleCondition[Any]]:
+        for condition in self.conditions:
+            if condition.field == item:
+                yield condition

annet/rpl/match_builder.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, Sequence, Callable, Optional, TypeVar, Any
+
+from .condition import SingleCondition, ConditionOperator, AndCondition
+
+
+class MatchField(str, Enum):
+    community = "community"
+    extcommunity = "extcommunity"
+    rd = "rd"
+    interface = "interface"
+    protocol = "protocol"
+    net_len = "net_len"
+    local_pref = "local_pref"
+    metric = "metric"
+    family = "family"
+
+    as_path_length = "as_path_length"
+    as_path_filter = "as_path_filter"
+    ipv6_prefix = "ipv6_prefix"
+    ip_prefix = "ip_prefix"
+
+
+ValueT = TypeVar("ValueT")
+_ConditionMethod = Callable[["ConditionFactory[ValueT]", ValueT], SingleCondition[ValueT]]
+
+
+def condition_method(operator: ConditionOperator) -> _ConditionMethod:
+    def method(self: "ConditionFactory[ValueT]", other: ValueT) -> SingleCondition[ValueT]:
+        if operator.value not in self.supported_ops:
+            raise NotImplementedError(f"Operator {operator.value} is not supported for field {self.field}")
+        return SingleCondition(self.field, operator, other)
+
+    method.__name__ = operator.value
+    return method
+
+
+class ConditionFactory(Generic[ValueT]):
+    def __init__(self, field: str, supported_ops: list[str]):
+        self.field = field
+        self.supported_ops = supported_ops
+
+    # https://github.com/python/typeshed/issues/3685
+    eq = __eq__ = condition_method(ConditionOperator.EQ)  # type: ignore[assignment]
+    gt = __gt__ = condition_method(ConditionOperator.GT)
+    ge = __ge__ = condition_method(ConditionOperator.GE)
+    lt = __lt__ = condition_method(ConditionOperator.LT)
+    le = __le__ = condition_method(ConditionOperator.LE)
+    between_included = condition_method(ConditionOperator.BETWEEN_INCLUDED)
+
+
+class SetConditionFactory(Generic[ValueT]):
+    def __init__(self, field: str) -> None:
+        self.field = field
+
+    def has(self, *values: ValueT) -> SingleCondition[Sequence[ValueT]]:
+        return SingleCondition(self.field, ConditionOperator.HAS, values)
+
+    def has_any(self, *values: ValueT) -> SingleCondition[Sequence[ValueT]]:
+        return SingleCondition(self.field, ConditionOperator.HAS_ANY, values)
+
+
+@dataclass(frozen=True)
+class PrefixMatchValue:
+    names: Sequence[str]
+    or_longer: Optional[tuple[int, int]]  # ????
+
+
+class Checkable:
+    def __init__(self):
+        self.community = SetConditionFactory[str](MatchField.community)
+        self.extcommunity = SetConditionFactory[str](MatchField.extcommunity)
+        self.rd = SetConditionFactory[str](MatchField.rd)
+        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.metric = ConditionFactory[int](MatchField.metric, ["=="])
+        self.family = ConditionFactory[int](MatchField.family, ["=="])
+        self.as_path_length = ConditionFactory[int](MatchField.as_path_length, ["==", ">=", "<=", "BETWEEN_INCLUDED"])
+
+    def as_path_filter(self, name: str) -> SingleCondition[str]:
+        return SingleCondition(MatchField.as_path_filter, ConditionOperator.EQ, name)
+
+    def match_v6(self, *names: str, or_longer: Optional[tuple[int, int]] = None) -> SingleCondition[PrefixMatchValue]:
+        return SingleCondition(MatchField.ipv6_prefix, ConditionOperator.CUSTOM, PrefixMatchValue(names, or_longer))
+
+    def match_v4(self, *names: str, or_longer: Optional[tuple[int, int]] = None) -> SingleCondition[PrefixMatchValue]:
+        return SingleCondition(MatchField.ip_prefix, ConditionOperator.CUSTOM, PrefixMatchValue(names, or_longer))
+
+
+def merge_conditions(and_condition: AndCondition) -> AndCondition:
+    conditions: dict[str, SingleCondition[Any]] = {}
+    for condition in and_condition.conditions:
+        if condition.field in conditions:
+            conditions[condition.field] = conditions[condition.field].merge(condition)
+        else:
+            conditions[condition.field] = condition
+    return AndCondition(*conditions.values())
+
+
+R = Checkable()

annet/rpl/policy.py

@@ -0,0 +1,22 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Optional
+
+from .action import Action
+from .condition import AndCondition
+from .result import ResultType
+
+
+@dataclass
+class RoutingPolicyStatement:
+    name: Optional[str]
+    number: Optional[int]
+    match: AndCondition
+    then: Action
+    result: ResultType
+
+
+@dataclass
+class RoutingPolicy:
+    name: str
+    statements: Sequence[RoutingPolicyStatement]

annet/rpl/result.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ResultType(str, Enum):
+    ALLOW = "allow"
+    DENY = "deny"
+    NEXT = "next"
+    NEXT_POLICY = "next_policy"

annet/rpl/routemap.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass
+from typing import Optional, Callable, Generic, TypeVar, Union
+
+from .action import Action
+from .condition import AndCondition, Condition
+from .match_builder import merge_conditions
+from .policy import RoutingPolicy, RoutingPolicyStatement
+from .result import ResultType
+from .statement_builder import StatementBuilder
+
+
+class Route:
+    def __init__(self, name: str):
+        self.name = name
+        self.statements: list[RoutingPolicyStatement] = []
+
+    def __call__(
+            self,
+            *conditions: Condition,
+            name: Optional[str] = None,
+            number: Optional[int] = None,
+    ) -> "StatementBuilder":
+        statement = RoutingPolicyStatement(
+            name=name,
+            number=number,
+            match=merge_conditions(AndCondition(*conditions)),
+            then=Action(),
+            result=ResultType.NEXT,
+        )
+        self.statements.append(statement)
+        return StatementBuilder(statement=statement)
+
+
+DeviceT = TypeVar("DeviceT")
+RouteHandlerFunc = Callable[[DeviceT, Route], None]
+Decorator = Callable[[RouteHandlerFunc[DeviceT]], RouteHandlerFunc[DeviceT]]
+
+
+@dataclass
+class Handler(Generic[DeviceT]):
+    name: str
+    func: RouteHandlerFunc[DeviceT]
+
+
+class RouteMap(Generic[DeviceT]):
+    def __init__(self) -> None:
+        self.handlers: list[Handler[DeviceT]] = []
+        self.submaps: list[RouteMap[DeviceT]] = []
+
+    def __call__(
+            self, func: Optional[RouteHandlerFunc[DeviceT]] = None, *, name: str = "",
+    ) -> Union[RouteHandlerFunc[DeviceT], Decorator[DeviceT]]:
+        def decorator(func: RouteHandlerFunc[DeviceT]) -> RouteHandlerFunc[DeviceT]:
+            nonlocal name
+            if not name:
+                name = func.__name__
+            self.handlers.append(Handler(name, func))
+            return func
+
+        if func is None:
+            return decorator
+        return decorator(func)
+
+    def include(self, other: "RouteMap[DeviceT]") -> None:
+        self.submaps.append(other)
+
+    def apply(self, device: DeviceT) -> list[RoutingPolicy]:
+        result: list[RoutingPolicy] = []
+
+        for handler in self.handlers:
+            route = Route(handler.name)
+            handler.func(device, route)
+            result.append(RoutingPolicy(route.name, route.statements))
+        for submap in self.submaps:
+            result.extend(submap.apply(device))
+        return result