annet 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

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

@@ -132,6 +132,9 @@
     "PC.Whitebox.Ufispace.S": " S",
     "PC.Whitebox.Ufispace.S.S9100": " S91\\d\\d",
     "PC.Whitebox.Ufispace.S.S9100.S9110_32X": " S9110-32X",
+    "PC.Whitebox.Ufispace.S.S9300": " S93\\d\\d",
+    "PC.Whitebox.Ufispace.S.S9300.S9301_32DB": " S9301-32DB",
+    "PC.Whitebox.Ufispace.S.S9300.S9321_64EO": " S9321-64EO",
     "PC.Nebius": "^Nebius",
     "PC.Nebius.NB-E-BR-DCU-AST2600": "^Nebius NB-E-BR-DCU-AST2600",
 

annet/annlib/patching.py

@@ -186,6 +186,9 @@ class Orderer:
         block_exit = platform.VENDOR_EXIT[self.vendor]
 
         for (order, (raw_rule, rule)) in enumerate(ordering.items()):
+            if rule["attrs"]["global"]:
+                children.append((raw_rule, rule))
+
             direct_matched = bool(rule["attrs"]["direct_regexp"].match(row))
             if not rule["attrs"]["order_reverse"] and (direct_matched or rule["attrs"]["reverse_regexp"].match(row)):
                 # если не указано order_reverse - правило считается прямым
@@ -395,7 +398,7 @@ def make_patch(pre, rb, hw, add_comments, orderer=None, _root_pre=None, do_commi
         for (key, diff) in content["items"].items():
             # чтобы logic не мог поменять атрибуты
             rule_pre = content.copy()
-            attrs = rule_pre["attrs"].copy()
+            attrs = copy.deepcopy(rule_pre["attrs"])
 
             iterable = attrs["logic"](
                 rule=attrs,
@@ -544,8 +547,7 @@ def _select_match(matches, rules):
         for (rule, is_cr_allowed) in map(operator.itemgetter(0), matches):
             if is_cr_allowed:
                 local_children = merge_dicts(local_children, rule["children"]["local"])
-            # optional break on is_cr_allowed==False?
-
+                # optional break on is_cr_allowed==False?
                 global_children = merge_dicts(global_children, rule["children"]["global"])
 
     global_children = merge_dicts(global_children, rules["global"])
@@ -555,9 +557,10 @@ def _select_match(matches, rules):
         "global": global_children,
     }
 
-    match = {"attrs": f_rule["attrs"]}
+    match = {"attrs": copy.deepcopy(f_rule["attrs"])}
     match.update(f_other)
-    return (match, children_rules)
+
+    return match, children_rules
 
 
 def _rules_local_global(rules):

annet/annlib/rbparser/ordering.py

@@ -16,6 +16,10 @@ def compile_ordering_text(text, vendor):
                 "validator": valid_bool,
                 "default":   False,
             },
+            "global": {
+                "validator": valid_bool,
+                "default": False,
+            }
         }),
         reverse_prefix=platform.VENDOR_REVERSES[vendor],
     )
@@ -44,6 +48,7 @@ def _compile_ordering(tree, reverse_prefix):
                         syntax.compile_row_regexp(re.sub(r"^%s\s+" % (reverse_prefix), "", attrs["row"]))
                     ),
                     "order_reverse": attrs["params"]["order_reverse"],
+                    "global": attrs["params"]["global"],
                     "raw_rule": attrs["raw_rule"],
                     "context": attrs["context"],
                 },

annet/annlib/rbparser/platform.py

@@ -25,7 +25,7 @@ VENDOR_DIFF = {
     "routeros": "common.default_diff",
     "aruba": "aruba.default_diff",
     "pc": "common.default_diff",
-    "ribbon": "ribbon.default_diff",
+    "ribbon": "common.default_diff",
     "b4com": "common.default_diff",
 }
 
@@ -40,7 +40,7 @@ VENDOR_DIFF_ORDERED = {
     "routeros": "common.ordered_diff",
     "aruba": "common.ordered_diff",
     "pc": "common.ordered_diff",
-    "ribbon": "ribbon.default_diff",
+    "ribbon": "common.ordered_diff",
     "b4com": "common.ordered_diff",
 }
 

annet/annlib/tabparser.py

@@ -1,6 +1,8 @@
 import dataclasses
 import itertools
+import json
 import re
+import textwrap
 from collections import OrderedDict as odict
 from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Tuple, Union, List
 
@@ -70,10 +72,10 @@ class CommonFormatter:
         self._block_end = ""
         self._statement_end = ""
 
-    def split(self, text):
+    def split(self, text: str):
         return list(filter(None, text.split("\n")))
 
-    def join(self, config):
+    def join(self, config: "PatchTree"):
         return "\n".join(
             _filtered_block_marks(
                 self._indent_blocks(self._blocks(config, is_patch=False))
@@ -86,14 +88,14 @@ class CommonFormatter:
     def diff(self, diff):
         return list(self.diff_generator(diff))
 
-    def patch(self, patch):
+    def patch(self, patch: "PatchTree") -> str:
         return "\n".join(
             _filtered_block_marks(
                 self._indent_blocks(self._blocks(patch, is_patch=True))
             )
         )
 
-    def cmd_paths(self, patch):
+    def cmd_paths(self, patch: "PatchTree") -> odict:
         ret = odict()
         path = []
         for row, context in self.blocks_and_context(patch, is_patch=True):
@@ -175,7 +177,7 @@ class CommonFormatter:
                 )
                 yield BlockEnd, None
 
-    def _blocks(self, tree, is_patch):
+    def _blocks(self, tree: "PatchTree", is_patch: bool):
         for row, _context in self.blocks_and_context(tree, is_patch):
             yield row
 
@@ -386,7 +388,32 @@ class AsrFormatter(BlockExitFormatter):
 
 
 class JuniperFormatter(CommonFormatter):
-    patch_set_prefix = "set "
+    patch_set_prefix = "set"
+
+    @dataclasses.dataclass
+    class Comment:
+        begin = "/*"
+        end = "*/"
+
+        row: str
+        comment: str
+
+        def __post_init__(self):
+            self.row = self.row.strip()
+            self.comment = self.comment.strip()
+
+        @classmethod
+        def loads(cls, value: str):
+            return cls(
+                **json.loads(
+                    value.removeprefix(cls.begin)
+                    .removesuffix(cls.end)
+                    .strip()
+                )
+            )
+
+        def dumps(self):
+            return json.dumps({"row": self.row, "comment": self.comment})
 
     def __init__(self, indent="    "):
         super().__init__(indent)
@@ -395,20 +422,32 @@ class JuniperFormatter(CommonFormatter):
         self._statement_end = ";"
         self._endofline_comment = "; ##"
 
-    def split(self, text):
-        sub_regexs = (
+        self._sub_regexs = (
             (re.compile(self._block_begin + r"\s*" + self._block_end + r"$"), ""),  # collapse empty blocks
             (re.compile(self._block_begin + "(\t# .+)?$"), ""),
             (re.compile(self._statement_end + r"$"), ""),
             (re.compile(r"\s*" + self._block_end + "(\t# .+)?$"), ""),
             (re.compile(self._endofline_comment + r".*$"), ""),
         )
-        split = []
-        for line in text.split("\n"):
-            for (regex, repl_line) in sub_regexs:
-                line = regex.sub(repl_line, line)
-            split.append(line)
-        return list(filter(None, split))
+
+    def sub_regexs(self, value: str) -> str:
+        for (regex, repl_line) in self._sub_regexs:
+            value = regex.sub(repl_line, value)
+        return value
+
+    def split(self, text: str) -> list[str]:
+        comment_begin, comment_end = map(re.escape, (self.Comment.begin, self.Comment.end))
+        comment_regexp = re.compile(fr"(\s+{comment_begin})((?:(?!{comment_end}).)*)({comment_end})")
+
+        result = []
+        lines = text.split("\n")
+        for i, line in enumerate(lines):
+            line = self.sub_regexs(line)
+            if i + 1 < len(lines) and (m := comment_regexp.match(line)):
+                line = f"{m.group(1)} {self.Comment(self.sub_regexs(lines[i + 1]), m.group(2)).dumps()} {m.group(3)}"
+            result.append(line)
+
+        return list(filter(None, result))
 
     def join(self, config):
         return "\n".join(_filtered_block_marks(self._formatted_blocks(self._indented_blocks(config))))
@@ -433,30 +472,45 @@ class JuniperFormatter(CommonFormatter):
                     yield line + self._statement_end
                 yield self._indent * level + self._block_end
             elif isinstance(line, str):
-                yield line + self._statement_end
+                yield line + ("" if line.endswith(self.Comment.end) else self._statement_end)
             line = new_line
         if isinstance(line, str):
             yield line + self._statement_end
 
-    def cmd_paths(self, patch, _prev=""):
+    def cmd_paths(self, patch, _prev=tuple()):
         commands = odict()
         for item in patch.itms:
             key, childs, context = item.row, item.child, item.context
+
             if childs:
-                for k, v in self.cmd_paths(childs, _prev + " " + key).items():
+                for k, v in self.cmd_paths(childs, (*_prev, key.strip())).items():
                     commands[k] = v
             else:
-                if key.startswith("delete"):
-                    cmd = "delete" + _prev + " " + key.replace("delete", "", 1).strip()
+                if "comment" in context:
+                    value = (
+                        ""
+                        if key.startswith("delete")
+                        else context["comment"]
+                    )
+
+                    cmd = "\n".join(
+                        (
+                            "edit " + " ".join(_prev),
+                            " ".join(("annotate", context["row"].split(" ")[0], f'"{value}"')),
+                            "exit"
+                        )
+                    )
+                elif key.startswith("delete"):
+                    cmd = " ".join(("delete", *_prev, key.replace("delete", "", 1).strip()))
                 elif key.startswith("activate"):
-                    cmd = "activate" + _prev + " " + key.replace("activate", "", 1).strip()
+                    cmd = " ".join(("activate", *_prev, key.replace("activate", "", 1).strip()))
                 elif key.startswith("deactivate"):
-                    cmd = "deactivate" + _prev + " " + key.replace("deactivate", "", 1).strip()
+                    cmd = " ".join(("deactivate", *_prev, key.replace("deactivate", "", 1).strip()))
                 else:
-                    cmd = (self.patch_set_prefix + _prev.strip()).strip() + " " + key
+                    cmd = " ".join((self.patch_set_prefix, *_prev, key.strip()))
+
                 # Expanding [ a b c ] junipers list of arguments
-                matches = re.search(r"^(.*)\s+\[(.+)\]$", cmd)
-                if matches:
+                if matches := re.search(r"^(.*)\s+\[(.+)\]$", cmd):
                     for c in matches.group(2).split(" "):
                         if c.strip():
                             cmd = " ".join([matches.group(1), c])
@@ -490,7 +544,7 @@ class JuniperList:
 
 
 class NokiaFormatter(JuniperFormatter):
-    patch_set_prefix = "/configure "
+    patch_set_prefix = "/configure"
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -517,18 +571,18 @@ class NokiaFormatter(JuniperFormatter):
         finish = finish if finish is not None else len(ret)
         return ret[start:finish]
 
-    def cmd_paths(self, patch, _prev=""):
+    def cmd_paths(self, patch, _prev=tuple()):
         commands = odict()
         for item in patch.itms:
             key, childs, context = item.row, item.child, item.context
             if childs:
-                for k, v in self.cmd_paths(childs, _prev + " " + key).items():
+                for k, v in self.cmd_paths(childs, (*_prev, key.strip())).items():
                     commands[k] = v
             else:
                 if key.startswith("delete"):
-                    cmd = "/configure delete" + _prev + " " + key.replace("delete", "", 1).strip()
+                    cmd = " ".join((self.patch_set_prefix, "delete", *_prev, key.replace("delete", "", 1).strip()))
                 else:
-                    cmd = self.patch_set_prefix + _prev.strip() + " " + key
+                    cmd = " ".join((self.patch_set_prefix, *_prev, key.strip()))
                 # Expanding [ a b c ] junipers list of arguments
                 matches = re.search(r"^(.*)\s+\[(.+)\]$", cmd)
                 if matches:

annet/bgp_models.py

@@ -3,6 +3,77 @@ from dataclasses import dataclass, field
 from typing import Literal, Union, Optional
 
 
+class VidRange:
+    def __init__(self, start: int, stop: int) -> None:
+        self.start = start
+        self.stop = stop
+
+    def is_single(self):
+        return self.start == self.stop
+
+    def __iter__(self):
+        return iter(range(self.start, self.stop + 1))
+
+    def __str__(self):
+        if self.is_single():
+            return str(self.start)
+        return f"{self.start}-{self.stop}"
+
+    def __repr__(self):
+        return f"VlanRange({self.start}, {self.stop})"
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is VidRange:
+            return self.start == other.start and self.stop == other.stop
+        return NotImplemented
+
+
+def _parse_vlan_ranges(ranges: str) -> Iterable[VidRange]:
+    for range in ranges.split(","):
+        start, sep, stop = range.strip().partition("-")
+        try:
+            if not sep:
+                int_start = int(start)
+                yield VidRange(int_start, int_start)
+            elif not stop or not start:
+                raise ValueError(f"Cannot parse range {range!r}. Expected `start-stop`")
+            else:
+                yield VidRange(int(start), int(stop))
+        except ValueError:
+            raise ValueError(f"Cannot parse range {range!r}. Expected `vid1-vid2` or `vid`")
+
+
+class VidCollection:
+    @staticmethod
+    def parse(ranges: int | str) -> "VidCollection":
+        if isinstance(ranges, int):
+            return VidCollection([VidRange(ranges, ranges)])
+        elif isinstance(ranges, str):
+            return VidCollection(list(_parse_vlan_ranges(ranges)))
+        elif isinstance(ranges, VidCollection):
+            return VidCollection(ranges.ranges)
+        else:
+            raise TypeError(f"Expected str or int, got {type(ranges)}")
+
+    def __init__(self, ranges: list[VidRange]) -> None:
+        self.ranges = ranges
+
+    def __str__(self):
+        return ",".join(map(str, self.ranges))
+
+    def __repr__(self):
+        return f"VlanCollection({str(self)!r})"
+
+    def __iter__(self):
+        for range in self.ranges:
+            yield from range
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is VidCollection:
+            return self.ranges == other.ranges
+        return False
+
+
 class ASN(int):
     """
     Stores ASN number and formats it as в AS1.AS2
@@ -235,6 +306,17 @@ class PeerGroup:
     mtu: int = 0
 
 
+@dataclass
+class L2VpnOptions:
+    name: str
+    vid: VidCollection
+    l2vni: int  # VNI, possible values are 1 to 2**24-1
+    route_distinguisher: str = ""  # like in VrfOptions
+    rt_import: list[str] = field(default_factory=list)  # like in VrfOptions
+    rt_export: list[str] = field(default_factory=list)  # like in VrfOptions
+    advertise_host_routes: bool = True  # advertise IP+MAC routes into L3VNI
+
+
 @dataclass
 class VrfOptions:
     vrf_name: str
@@ -274,8 +356,8 @@ class GlobalOptions:
     multipath: int = 0
     router_id: str = ""
     vrf: dict[str, VrfOptions] = field(default_factory=dict)
-
     groups: list[PeerGroup] = field(default_factory=list)
+    l2vpn: dict[str, L2VpnOptions] = field(default_factory=dict)
 
 
 @dataclass