annet 3.15.1__tar.gz → 3.16.0__tar.gz

{annet-3.15.1/annet.egg-info → annet-3.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annet
-Version: 3.15.1
+Version: 3.16.0
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-3.15.1 → annet-3.16.0}/annet/adapters/file/provider.py

@@ -10,6 +10,7 @@ from annet.connectors import AdapterWithName
 from annet.hardware import hardware_connector
 from annet.storage import Device as DeviceProtocol
 from annet.storage import Query, Storage, StorageProvider
+from annet.adapters.netbox.common.manufacturer import get_breed
 
 
 @dataclass
@@ -30,6 +31,7 @@ class DeviceStorage:
     vendor: Optional[str] = None
     hw_model: Optional[str] = None
     sw_version: Optional[str] = None
+    breed: Optional[str] = None
 
     hostname: Optional[str] = None
     serial: Optional[str] = None
@@ -59,6 +61,14 @@ class DeviceStorage:
             self.hw_model = hw.model
         self.hw = hw
 
+        if not self.breed:
+            if self.hw.model:
+                parts = self.hw.model.split(maxsplit=1)
+                if len(parts) >= 2:
+                    self.breed = get_breed(parts[0], parts[1])
+            if not self.breed:
+                self.breed = self.hw.vendor
+
         if isinstance(self.interfaces, list):
             interfaces = []
             for iface in self.interfaces:
@@ -107,7 +117,7 @@ class Device(DeviceProtocol, DumpableView):
 
     @property
     def breed(self) -> str:
-        return self.dev.hw.vendor
+        return self.dev.breed
 
     @property
     def neighbours_ids(self):

{annet-3.15.1 → annet-3.16.0}/annet/annlib/netdev/devdb/data/devdb.json

@@ -20,23 +20,24 @@
     "Cisco.Catalyst.C3700": "37\\d\\d",
     "Cisco.Catalyst.C4900": "49\\d\\d",
     "Cisco.Catalyst.C6500": "65\\d\\d",
-    "Cisco.Nexus": " [Nn]exus",
-    "Cisco.Nexus.N3x": " 3\\d\\d\\d",
-    "Cisco.Nexus.N3x.N3100": " 31\\d\\d",
-    "Cisco.Nexus.N3x.N3432": " 3432",
-    "Cisco.Nexus.N3x.N3500": " 35\\d\\d",
-    "Cisco.Nexus.N5x": " 5\\d\\d\\d",
-    "Cisco.Nexus.N5x.N5000": " 50\\d\\d",
-    "Cisco.Nexus.N5x.N5500": " 55\\d\\d",
-    "Cisco.Nexus.N6x": " 6\\d\\d\\d",
-    "Cisco.Nexus.N6x.N6000": " 60\\d\\d",
-    "Cisco.Nexus.N7x": " 7\\d{3}",
-    "Cisco.Nexus.N7x.N7000": " 70\\d\\d",
-    "Cisco.Nexus.N7x.N7700": " 77\\d\\d",
+
+    "Cisco.Nexus": " [Nn](exus)?",
+    "Cisco.Nexus.N3x": " (N3K-[A-Z])?3\\d\\d\\d",
+    "Cisco.Nexus.N3x.N3100": "31\\d\\d",
+    "Cisco.Nexus.N3x.N3432": "3432",
+    "Cisco.Nexus.N3x.N3500": "35\\d\\d",
+    "Cisco.Nexus.N5x": " (N5K-[A-Z])?5\\d\\d\\d",
+    "Cisco.Nexus.N5x.N5000": "50\\d\\d",
+    "Cisco.Nexus.N5x.N5500": "55\\d\\d",
+    "Cisco.Nexus.N6x": " (N6K-[A-Z])?6\\d\\d\\d",
+    "Cisco.Nexus.N6x.N6000": "60\\d\\d",
+    "Cisco.Nexus.N7x": " (N7K-[A-Z])?7\\d\\d\\d",
+    "Cisco.Nexus.N7x.N7000": "70\\d\\d",
+    "Cisco.Nexus.N7x.N7700": "77\\d\\d",
     "Cisco.Nexus.N9x": " (N9K-[A-Z])?9\\d\\d\\d",
-    "Cisco.Nexus.N9x.N9316": " 9316",
-    "Cisco.Nexus.N9x.N9500": " 95\\d\\d",
-    "Cisco.Nexus.N9x.N9364": " N9K-C9364",
+    "Cisco.Nexus.N9x.N9316": "9316",
+    "Cisco.Nexus.N9x.N9500": "95\\d\\d",
+    "Cisco.Nexus.N9x.N9364": "9364",
 
     "Huawei": "^[Hh]uawei",
     "Huawei.CE": " CE\\d+",

{annet-3.15.1 → annet-3.16.0}/annet/annlib/netdev/views/hardware.py

@@ -36,9 +36,12 @@ class HardwareLeaf(DumpableView):
             raise AttributeError("HW: " + ".".join(path))
 
     def __str__(self):
-        return str(" | ".join(".".join(x) for x in self.__true_sequences))
+        for seq in sorted(self.__true_sequences, key=len, reverse=True):
+            return ".".join(seq)
+        return ""
 
-    __repr__ = __str__
+    def __repr__(self):
+        return str(" | ".join(".".join(x) for x in self.__true_sequences))
 
     def dump(self, prefix, **kwargs):  # pylint: disable=arguments-differ
         ret = super().dump(prefix, **kwargs)
@@ -103,4 +106,6 @@ def lag_name(hw: HardwareView, nlagg: int) -> str:
         return f"lagg{nlagg}"
     if hw.Nokia:
         return f"lagg-{nlagg}"
+    if hw.H3C:
+        return f"Bridge-Aggregation{nlagg}"
     raise NotImplementedError(hw)

{annet-3.15.1 → annet-3.16.0}/annet/annlib/output.py

@@ -114,7 +114,7 @@ class Dumpable(abc.ABC):
         pass
 
 
-def print_as_json(data, fh=sys.stdout):
+def print_as_json(data, fh=sys.stdout, highlight=True):
     """
     В выводе dict ключи отсортированы по имени, кроме ключей в OrderedDict,
     которые сохраняют свой оригинальный порядок
@@ -176,17 +176,19 @@ def print_as_json(data, fh=sys.stdout):
             except TypeError:
                 raise TypeError("can't serialize %r to json" % o)
 
-    dump = json.dumps(UnsortableOdict.convert_odicts(data), cls=JsonEncoder,
-                      ensure_ascii=False, indent=4, sort_keys=True) + "\n"
-    if fh.isatty():
+    dump_data = UnsortableOdict.convert_odicts(data)
+    dump_kwargs = dict(cls=JsonEncoder, ensure_ascii=False)
+
+    if fh.isatty() and highlight:
         pygments.highlight(
-            code=dump,
+            code=json.dumps(dump_data, indent=4, sort_keys=True, **dump_kwargs) + "\n",
             lexer=pygments.lexers.data.JsonLexer(),
             formatter=pygments.formatters.TerminalFormatter(bg="dark"),
             outfile=fh,
         )
     else:
-        fh.write(dump)
+        json.dump(dump_data, fh, **dump_kwargs)
+        fh.write("\n")
 
 
 class TextArgs:

annet-3.16.0/annet/annlib/rbparser/platform.py

@@ -0,0 +1 @@
+VENDOR_ALIASES: dict[str, str] = {}

annet-3.16.0/annet/rulebook/h3c/aaa.py

@@ -0,0 +1,28 @@
+from annet.annlib.types import Op
+
+
+def user(key, diff, **_):
+    check_for_remove = True
+    added = []
+    for add in diff[Op.ADDED]:
+        added.append((True, add["row"], None))
+        if add["row"].startswith("local-user %s password" % key[0]):
+            check_for_remove = False
+    if check_for_remove:
+        for rem in diff[Op.REMOVED]:
+            # we abe able to overwrite new command without undo
+            if rem["row"].startswith("local-user %s password" % key[0]):
+                yield (False, "undo local-user %s" % key[0], None)
+                return
+            if (rem["row"].startswith("local-user %s privilege" % key[0])
+                    and not _added_contains(diff[Op.ADDED], "local-user %s privilege" % key[0])):
+                yield (False, "undo local-user %s" % key[0], None)
+                return
+    yield from added
+
+
+def _added_contains(array: list[dict], lookup_string: str) -> bool:
+    for item in array:
+        if item["row"].startswith(lookup_string):
+            return True
+    return False

annet-3.16.0/annet/rulebook/h3c/bgp.py

@@ -0,0 +1,84 @@
+import socket
+
+from annet.annlib.types import Op
+
+from annet.rulebook import common
+
+
+def peer(rule, key, diff, **_):  # pylint: disable=unused-argument
+    """
+    The peculiarity of peer commands is that
+        peer IP as-number N
+    is the main command, and it can only be removed with
+        undo peer IP
+    which completely deletes all settings of the peer.
+    At the same time, the as-number can also be set for a group:
+        group SPINES
+        peer SPINES as-number 13238
+    In this case, we ignore it and allow this setting to be deleted, since it does not define the group itself:
+        undo peer SPINES as-number
+    """
+
+    assert not diff[Op.AFFECTED], "Peer commands could not contain subcommands"
+    for action in sorted(diff[Op.REMOVED], key=lambda act: "as-number" not in act["row"].split()):
+        tokens = action["row"].split()
+        (_, addr_or_group_name, param, *__) = tokens
+        if param == "as-number":
+            if _is_ip_addr(addr_or_group_name):
+                yield (False, "undo peer {}".format(*key), None)
+            else:
+                # We can’t use common.default because the rule is defined as "peer *" and not "peer * *".
+                # Therefore, the default behavior here would be "undo peer PEERGROUP", which is not what we want.
+                yield (False, "undo peer {} as-number".format(*key), None)
+            break
+
+        if param in ["connect-interface", "ebgp-max-hop", "local-as", "substitute-as", "password", "preferred-value"]:
+            yield (False, "undo " + " ".join(tokens[:3]), None)
+        else:
+            yield (False, "undo " + action["row"], None)
+
+    for action in sorted(diff[Op.ADDED], key=lambda act: "as-number" not in act["row"]):
+        yield (True, action["row"], None)
+
+
+def bfd(rule, key, diff, **_):
+    """
+    [*vla-1x1-bgp]undo peer SPINE1 bfd min-tx-interval 500 min-rx-interval 500 detect-multiplier 4
+    │Error: Unrecognized command found at '^' position.
+
+    [*vla-1x1-bgp]undo peer SPINE1 bfd min-rx-interval
+    [~vla-1x1-bgp]undo peer SPINE1 bfd min-tx-interval
+    [*vla-1x1-bgp]undo peer SPINE1 bfd detect-multiplier
+    """
+    if diff[Op.REMOVED]:
+        assert len(diff[Op.REMOVED]) <= 1 and len(diff[Op.ADDED]) <= 1
+        new_params = set()
+        if diff[Op.ADDED]:
+            new_params = set(_bfd_params_used(diff[Op.ADDED][0]["row"]))
+        for token in _bfd_params_used(diff[Op.REMOVED][0]["row"]):
+            if token not in new_params:
+                yield (False, rule["reverse"].format(*key) + " " + token, None)
+        diff[Op.REMOVED] = []
+    if diff[Op.ADDED]:
+        yield from common.default(rule, key, diff, **_)
+
+
+def _is_ip_addr(addr_or_string):
+    ret = None
+    for af in (socket.AF_INET6, socket.AF_INET):
+        try:
+            ret = socket.inet_pton(af, addr_or_string)
+        except OSError:
+            pass
+        else:
+            break
+    return bool(ret)
+
+
+def _bfd_params_used(row):
+    prev = None
+    for token in row.split():
+        if prev and token.isnumeric():
+            if prev and token.isnumeric():
+                yield prev
+        prev = token

annet-3.16.0/annet/rulebook/h3c/iface.py

@@ -0,0 +1,22 @@
+from annet.annlib.types import Op
+
+from annet.rulebook import common
+
+
+# [NOCDEV-2180] After vrf was change we put ip config one more time
+def binding_change(old, new, diff_pre, _pops=(Op.AFFECTED,)):
+    ret = common.default_diff(old, new, diff_pre, _pops)
+    vpn_changed = False
+    for (op, cmd, _, _) in ret:
+        if op in {Op.ADDED, Op.REMOVED}:
+            vpn_changed |= _is_vpn_cmd(cmd)
+    if vpn_changed:
+        for cmd in list(old.keys()):
+            if not _is_vpn_cmd(cmd):
+                del old[cmd]
+        ret = common.default_diff(old, new, diff_pre, _pops)
+    return ret
+
+
+def _is_vpn_cmd(cmd):
+    return cmd.startswith("ip binding vpn-instance")

annet-3.16.0/annet/rulebook/h3c/misc.py

@@ -0,0 +1,280 @@
+import copy
+
+from annet.annlib.types import Op
+
+from annet.rulebook import common
+
+
+def rp_node(rule, key, diff, **_):
+    # route-policy NAME ACTION node NUM
+    (rp_name, node_id) = key
+    if diff[Op.REMOVED]:
+        if diff[Op.ADDED]:
+            sub_diff = {Op.AFFECTED: [], Op.ADDED: [], Op.REMOVED: [], Op.MOVED: [], Op.UNCHANGED: []}
+            sub_diff[Op.AFFECTED] = diff[Op.REMOVED]
+            yield from common.default(rule, key, sub_diff)
+        else:
+            yield (False, "undo route-policy %s node %s" % (rp_name, node_id), None)
+
+    if diff[Op.AFFECTED] or diff[Op.ADDED]:
+        yield from common.default(rule, key, diff)
+
+
+def undo_redo(rule, key, diff, **_):
+    yield from common.undo_redo(rule, key, diff, **_)
+
+
+def prefix_list(rule, key, diff, **kwargs):
+    # To determine whether the prefix list is being fully modified,
+    # the key (family, name) is defined in the h3c.rul rulebook.
+    # However, from the command’s point of view, each index represents a separate command.
+    # Therefore, we group them by index here and pass them to common.
+    diff_by_index = {}
+    for op, rows in diff.items():
+        for row in rows:
+            # prefix list format:
+            # ip ip-prefix PRFX_CT_LU_ALLOWED_ROUTES index 15 ..
+            # ip ipv6-prefix PFXS_SPECIALv6 index 20 ..
+            _ip, _family, _name, _index, index, *_ = row["row"].split()
+            if index not in diff_by_index:
+                sub_diff = {op: [] for op in diff.keys()}
+                diff_by_index[index] = sub_diff
+            diff_by_index[index][op].append(row)
+
+    family, name = key
+    if family not in {"ip", "ipv6"}:
+        raise NotImplementedError("Unknown family '%s'" % family)
+    if diff[Op.ADDED] or diff[Op.REMOVED] or diff[Op.MOVED]:
+        # Since the rule key originally doesn’t include the index,
+        # we need to add it; otherwise, the undo rule will be missing it.
+        indexed_rule = copy.deepcopy(rule)
+        indexed_rule["reverse"] = "undo ip {}-prefix {} index {}"
+
+        # The stub_index is referenced in the h3c.order rulebook
+        # to ensure that the stub is added or removed first or last in order.
+
+        stub, stub_index = "", 99999999
+
+        # If we’re only adding new commands (for example, creating entries) in the prefix list,
+        # or deleting/moving them while keeping some parts unchanged,
+        # h3c will not treat the list as being removed, and the stub rule is not needed.
+
+        if (diff[Op.REMOVED] or diff[Op.MOVED]) and not diff[Op.UNCHANGED]:
+            stub = "deny 0.0.0.0 32" if family == "ip" else "deny :: 128"
+        if stub:
+            yield (True, f"ip {family}-prefix {name} index {stub_index} {stub}", None)
+        for index, sub_diff in diff_by_index.items():
+            yield from common.undo_redo(indexed_rule, (family, name, index), sub_diff, **kwargs)
+        if stub:
+            yield (False, f"undo ip {family}-prefix {name} index {stub_index}", None)
+
+
+def static(rule, key, diff, **_):
+    """
+    To roll back a static route, we actually need to pass almost all arguments
+    except for the various "track" options.
+    At the same time, the number of arguments may vary — optional VRF, optional interface.
+    Therefore, we don’t parse the command itself; we just remove the unnecessary arguments.
+    """
+    if diff[Op.REMOVED]:
+        param = key[0]
+        idx = param.find(" track")
+        if idx > 0:
+            key = (param[0:idx],)
+        idx = param.find(" description")
+        if idx > 0:
+            key = (param[0:idx],)
+        idx = param.find(" preference")
+        if idx > 0:
+            key = (param[0:idx],)
+    yield from common.default(rule, key, diff)
+
+
+def port_queue(rule, key, diff, **_):
+    """
+    To roll back the port-queue configuration on an interface, only a partial parameter specification is required.
+    Example of disabling/enabling:
+    interface 100GE0/1/33
+        undo port-queue af3 wfq outbound
+        port-queue af3 wfq weight 30 port-wred WRED outbound
+
+    Essentially, we need to remove all parameters between 'wfq' and 'outbound'.
+    NOC-19414
+    """
+    if diff[Op.REMOVED]:
+        param = key[0]
+        idx = param.find("weight")
+        if idx > 0:
+            key = (param[0:idx] + "outbound",)
+    yield from common.default(rule, key, diff)
+
+
+def netstream_undo(rule, key, diff, **_):
+    if diff[Op.REMOVED]:
+        # The only part we need is the last keyword: inbound or outbound
+        # Unfortunately, key is a tuple so we cast it to a list and back
+        key = list(key)
+        key[1] = key[1].split(" ")[-1]
+        key = tuple(key)
+    yield from common.default(rule, key, diff)
+
+
+def snmpagent_sysinfo_version(rule, key, diff, hw, **_):
+    yield from common.default(rule, key, diff)
+
+
+def vty_acl_undo(rule, key, diff, **_):
+    if diff[Op.REMOVED]:
+        chunks = key[0].split()
+        result_chunks = ["undo acl"]
+        if len(chunks) == 3 and chunks[0] == "ipv6":
+            result_chunks.append("ipv6")
+        result_chunks.append(chunks[-1])
+        yield False, " ".join(result_chunks), None
+    else:
+        yield from common.default(rule, key, diff)
+
+
+def port_split(rule, key, diff, **_):
+    # pylint: disable=unused-argument
+    def _port_split(old, new, old_row, new_row):
+        removed = set(old).difference(new)
+        added = set(new).difference(old)
+        if old and new:
+            for ifname in removed:
+                yield (False, "undo port split dimension interface " + ifname, None)
+            for ifname in added:
+                yield (True, "port split dimension interface " + ifname, None)
+        elif old and not new:
+            yield (False, "undo " + old_row, None)
+        elif new and not old:
+            yield (True, new_row, None)
+
+    def _row_slot(row):
+        res = ""
+        for ch in row:
+            if ch == "/":
+                break
+            res = res + ch if ch.isnumeric() else ""
+        return int(res) if res else 0
+
+    old_by_slot = {_row_slot(x["row"]): x["row"] for x in diff[Op.REMOVED]}
+    new_by_slot = {_row_slot(x["row"]): x["row"] for x in diff[Op.ADDED]}
+    for slot in set(old_by_slot.keys()).union(new_by_slot.keys()):
+        old_row = old_by_slot[slot] if slot in old_by_slot else ""
+        new_row = new_by_slot[slot] if slot in new_by_slot else ""
+        old = _expand_portsplit(old_row)
+        new = _expand_portsplit(new_row)
+        yield from _port_split(old, new, old_row, new_row)
+    if old_by_slot or new_by_slot:
+        yield (True, "port split refresh", None)
+
+
+def _expand_portsplit(row):
+    expanded = []
+    row_parts = row.split()
+    for (index, part) in enumerate(row_parts):
+        if part == "to":
+            iface_base = "/".join(row_parts[index - 1].split("/")[:-1])
+            left = int(row_parts[index - 1].split("/")[-1])
+            right = int(row_parts[index + 1].split("/")[-1])
+            for i in range(left + 1, right):
+                expanded.append(iface_base + "/" + str(i))
+        else:
+            expanded.append(part)
+    return expanded
+
+
+def classifier(rule, key, diff, **_):
+    # if type changes firstly remove all if-match
+    # and then recreate classifier
+    if diff[Op.ADDED] and diff[Op.REMOVED]:
+        yield (True, diff[Op.REMOVED][0]["row"], diff[Op.REMOVED][0]["children"])
+    yield from common.default(rule, key, diff)
+
+
+def undo_children(rule, key, diff, **_):
+    def removed_count(subdiff):
+        ret = 0
+        for child in subdiff["children"].values():
+            for child_diff in child["items"].values():
+                ret += len(child_diff[Op.REMOVED])
+        return ret
+
+    def common_default(op, subdiff):
+        newdiff = {Op.ADDED: [], Op.REMOVED: [], Op.MOVED: [], Op.AFFECTED: [], Op.UNCHANGED: []}
+        newdiff[op] = [subdiff]
+        yield from common.default(rule, key, newdiff)
+
+    # we should say undo because we pretend as single block
+    for subdiff in diff[Op.REMOVED]:
+        # firstly remove all group-members
+        if diff[Op.REMOVED][0]["children"]:
+            yield (True, diff[Op.REMOVED][0]["row"], diff[Op.REMOVED][0]["children"])
+        yield False, "undo " + subdiff["row"], None
+    # firstly destroy affected because inside we can have an undo
+    for subdiff in sorted(diff[Op.AFFECTED], key=removed_count, reverse=True):
+        yield from common_default(Op.AFFECTED, subdiff)
+    for subdiff in diff[Op.ADDED]:
+        yield from common_default(Op.ADDED, subdiff)
+
+
+def clear_instead_undo(rule, key, diff, **_):
+    # For some configuration lines, a persistent diff occurs because the line in the config is either explicitly enabled
+    # or explicitly disabled. If it is not described in the generator (i.e., we rely on the default),
+    # then by using "clear" instead of "undo" we return the configuration to its default state.
+    # NOC-20102 @gslv 11-02-2022
+    if diff[Op.REMOVED]:
+        if diff[Op.REMOVED][0]["row"].endswith(" disable"):
+            cmd = diff[Op.REMOVED][0]["row"].replace(" disable", "")
+            yield (True, "clear " + cmd, False)
+    else:
+        yield from common.default(rule, key, diff)
+
+
+def undo_port_link_mode(rule, key, diff, **_):
+    """
+    Сhanging port mode from bridge to route and back
+    """
+
+    if diff[Op.REMOVED]:
+        if key[0] == "route":
+            cmd = f"{diff[Op.REMOVED][0]['row']}".replace(key[0], "bridge")
+            yield (True, cmd, False)
+
+        if key[0] == "bridge":
+            cmd = f"{diff[Op.REMOVED][0]['row']}".replace(key[0], "route")
+            yield (True, cmd, False)
+
+
+def hardware_resource_bfd(rule, key, diff, **_):
+    """
+    Changing hardware-resource firmware-mode from software
+    to hardware and back without undo
+    """
+
+    if diff[Op.REMOVED]:
+        if key[0] == "INT-PTP":
+            cmd = f"{diff[Op.REMOVED][0]['row']}".replace(key[0], "INT-BFD")
+            yield (True, cmd, False)
+
+        if key[0] == "INT-BFD":
+            cmd = f"{diff[Op.REMOVED][0]['row']}".replace(key[0], "INT-PTP")
+            yield (True, cmd, False)
+
+
+def change_user_password(rule, key, diff, **_):
+    """
+    If we have to change password hash
+    then we just push new hash to configuration
+    without undo
+    """
+
+    if diff[Op.REMOVED]:
+        if key[0] == "route":
+            cmd = f"{diff[Op.REMOVED][0]['row']}".replace(key[0], "bridge")
+            yield (True, cmd, False)
+
+        if key[0] == "bridge":
+            cmd = f"{diff[Op.REMOVED][0]['row']}".replace(key[0], "route")
+            yield (True, cmd, False)