annet 0.16.16__tar.gz → 0.16.18__tar.gz

{annet-0.16.16/annet.egg-info → annet-0.16.18}/PKG-INFO

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

{annet-0.16.16 → annet-0.16.18}/annet/configs/context.yml

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

annet-0.16.18/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-0.16.18/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-0.16.18/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-0.16.18/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-0.16.18/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-0.16.18/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-0.16.18/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

annet-0.16.18/annet/rpl/statement_builder.py

@@ -0,0 +1,267 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from dataclasses import field
+from enum import Enum
+from typing import Optional, Literal, TypeVar, Union, Any
+
+from .action import SingleAction, ActionType
+from .policy import RoutingPolicyStatement
+from .result import ResultType
+
+
+class ThenField(str, Enum):
+    community = "community"
+    extcommunity = "extcommunity"
+    as_path = "as_path"
+    local_pref = "local_pref"
+    metric = "metric"
+    rpki_valid_state = "rpki_valid_state"
+    resolution = "resolution"
+    mpls_label = "mpls_label"
+    metric_type = "metric_type"
+    origin = "origin"
+    tag = "tag"
+
+    next_hop = "next_hop"
+
+
+ValueT = TypeVar("ValueT")
+_Setter = Callable[[ValueT], SingleAction[ValueT]]
+
+
+@dataclass
+class CommunityActionValue:
+    replaced: Optional[list[str]] = None  # None means no replacement is done
+    added: list[str] = field(default_factory=list)
+    removed: list[str] = field(default_factory=list)
+
+    def __bool__(self) -> bool:  # check if any action required
+        return bool(self.replaced is not None or self.added or self.removed)
+
+
+class CommunityActionBuilder:
+    def __init__(self, community: CommunityActionValue):
+        self._community = community
+
+    def add(self, *community: str) -> None:
+        for c in community:
+            self._community.added.append(c)
+
+    def remove(self, *community: str) -> None:
+        for c in community:
+            self._community.removed.append(c)
+
+    def set(self, *community: str) -> None:
+        self._community.added.clear()
+        self._community.removed.clear()
+        self._community.replaced = list(community)
+
+
+@dataclass
+class AsPathActionValue:
+    set: Optional[list[str]] = None  # None means no replacement is done
+    prepend: list[str] = field(default_factory=list)
+    expand: list[str] = field(default_factory=list)
+    expand_last_as: str = ""
+    delete: list[str] = field(default_factory=list)
+
+    def __bool__(self) -> bool:  # check if any action required
+        return bool(
+            self.set is not None or self.prepend or self.expand or self.expand_last_as or self.delete
+        )
+
+
+RawAsNum = Union[str, int]
+
+
+class AsPathActionBuilder:
+    def __init__(self, as_path_value: AsPathActionValue):
+        self._as_path_value = as_path_value
+
+    def prepend(self, *values: RawAsNum) -> None:
+        self._as_path_value.prepend = list(map(str, values))
+
+    def delete(self, *values: RawAsNum) -> None:
+        self._as_path_value.delete = list(map(str, values))
+
+    def expand(self, *values: RawAsNum) -> None:
+        self._as_path_value.expand = list(map(str, values))
+
+    def expand_last_as(self, value: RawAsNum) -> None:
+        self._as_path_value.expand_last_as = str(value)
+
+    def set(self, *values: RawAsNum) -> None:
+        self._as_path_value.expand.clear()
+        self._as_path_value.expand_last_as = ""
+        self._as_path_value.delete.clear()
+        self._as_path_value.prepend.clear()
+        self._as_path_value.set = list(map(str, values))
+
+
+@dataclass
+class NextHopActionValue:
+    target: Optional[Literal["self", "discard", "peer", "ipv4_addr", "ipv6_addr", "mapped_ipv4"]] = None
+    addr: str = ""
+
+    def __bool__(self) -> bool:
+        return bool(self.target)
+
+
+class NextHopActionBuilder:
+    def __init__(self, next_hop_value: NextHopActionValue):
+        self._next_hop_value = next_hop_value
+
+    def ipv4_addr(self, value: str) -> None:
+        self._next_hop_value.target = "ipv4_addr"
+        self._next_hop_value.addr = value
+
+    def ipv6_addr(self, value: str) -> None:
+        self._next_hop_value.target = "ipv6_addr"
+        self._next_hop_value.addr = value
+
+    def mapped_ipv4(self, value: str) -> None:
+        self._next_hop_value.target = "mapped_ipv4"
+        self._next_hop_value.addr = value
+
+    def self(self) -> None:
+        self._next_hop_value.target = "self"
+        self._next_hop_value.addr = ""
+
+    def peer(self) -> None:
+        self._next_hop_value.target = "peer"
+        self._next_hop_value.addr = ""
+
+    def discard(self) -> None:
+        self._next_hop_value.target = "discard"
+        self._next_hop_value.addr = ""
+
+
+class StatementBuilder:
+    def __init__(self, statement: RoutingPolicyStatement) -> None:
+        self._statement = statement
+        self._added_as_path: list[int] = []
+        self._community = CommunityActionValue()
+        self._extcommunity = CommunityActionValue()
+        self._as_path = AsPathActionValue()
+        self._next_hop = NextHopActionValue()
+
+    @property
+    def next_hop(self) -> NextHopActionBuilder:
+        return NextHopActionBuilder(self._next_hop)
+
+    @property
+    def as_path(self) -> AsPathActionBuilder:
+        return AsPathActionBuilder(self._as_path)
+
+    @property
+    def community(self) -> CommunityActionBuilder:
+        return CommunityActionBuilder(self._community)
+
+    @property
+    def extcommunity(self) -> CommunityActionBuilder:
+        return CommunityActionBuilder(self._extcommunity)
+
+    def _set(self, field: str, value: ValueT) -> None:
+        action = self._statement.then
+        if field in action:
+            action[field].type = ActionType.SET
+            action[field].value = value
+        else:
+            action.append(SingleAction(
+                field=field,
+                type=ActionType.SET,
+                value=value,
+            ))
+
+    def set_local_pref(self, value: int) -> None:
+        self._set(ThenField.local_pref, value)
+
+    def set_metric_type(self, value: str) -> None:
+        self._set(ThenField.metric_type, value)
+
+    def set_metric(self, value: int) -> None:
+        self._set(ThenField.metric, value)
+
+    def add_metric(self, value: int) -> None:
+        action = self._statement.then
+        field = ThenField.metric
+        if field in action:
+            old_action = action[field]
+            if old_action.type == ActionType.SET:
+                action[field].value += value
+            elif old_action.type == ActionType.ADD:
+                action[field].value = value
+            else:
+                raise RuntimeError(f"Unknown action type {old_action.type} for metric")
+        else:
+            action.append(SingleAction(
+                field=field,
+                type=ActionType.ADD,
+                value=value,
+            ))
+
+    def set_rpki_valid_state(self, value: str) -> None:
+        self._set(ThenField.rpki_valid_state, value)
+
+    def set_resolution(self, value: str) -> None:
+        self._set(ThenField.resolution, value)
+
+    def set_mpls_label(self) -> None:
+        self._set(ThenField.mpls_label, True)
+
+    def set_origin(self, value: str) -> None:
+        self._set(ThenField.origin, value)
+
+    def set_tag(self, value: int) -> None:
+        self._set(ThenField.tag, value)
+
+    def set_next_hop(self, value: Literal["self", "peer"]) -> None:  # ???
+        self._set(ThenField.next_hop, value)
+
+    def __enter__(self) -> "StatementBuilder":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._community:
+            self._statement.then.append(SingleAction(
+                field=ThenField.community,
+                type=ActionType.CUSTOM,
+                value=self._community,
+            ))
+        if self._extcommunity:
+            self._statement.then.append(SingleAction(
+                field=ThenField.extcommunity,
+                type=ActionType.CUSTOM,
+                value=self._extcommunity,
+            ))
+        if self._as_path:
+            self._statement.then.append(SingleAction(
+                field=ThenField.as_path,
+                type=ActionType.CUSTOM,
+                value=self._as_path,
+            ))
+        if self._next_hop:
+            self._statement.then.append(SingleAction(
+                field=ThenField.next_hop,
+                type=ActionType.CUSTOM,
+                value=self._next_hop,
+            ))
+        return None
+
+    def allow(self) -> None:
+        self._statement.result = ResultType.ALLOW
+
+    def deny(self) -> None:
+        self._statement.result = ResultType.DENY
+
+    def next(self) -> None:
+        self._statement.result = ResultType.NEXT
+
+    def next_policy(self) -> None:
+        self._statement.result = ResultType.NEXT_POLICY
+
+    def add_as_path(self, *as_path: int) -> None:
+        self._added_as_path.extend(as_path)
+
+    def custom_action(self, action: SingleAction[Any]) -> None:
+        self._statement.then.append(action)