annet 0.0__py3-none-any.whl

annet/rulebook/huawei/aaa.py

@@ -0,0 +1,75 @@
+from collections import defaultdict
+
+from annet.annlib.types import Op
+
+from annet.rulebook.common import default, default_diff
+
+
+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]:
+            # Обрабатывать удаление только пароля, если меняется что-то другое, можно просто накатить без удаления
+            if rem["row"].startswith("local-user %s password" % key[0]):
+                yield (False, "undo local-user %s" % key[0], None)
+                return
+    yield from added
+
+
+def domain(rule, key, diff, **_):
+    """
+    При удалении метода для accounting|authorization|authentication
+    не нужно указывать сам метод, поэтому откидываем последний ключ.
+    """
+    if diff[Op.REMOVED]:
+        yield (False, rule["reverse"].format(key[0], ""), None)
+    else:
+        yield from default(rule, key, diff)
+
+
+def local_user_diff(old, new, diff_pre, **kwargs):
+    diff = default_diff(old, new, diff_pre, **kwargs)
+    filtered_diff = []
+    # Группируем команды local-user по пользователю
+    # и назначению (mode будет "password", "service-type", etc.)
+    # {("username", "mode"): {op: diff_item}}}
+    grouped = defaultdict(dict)
+    for diff_item in diff:
+        username, mode = _local_user_row_key(diff_item.row)
+        if username and mode:
+            grouped[(username, mode)][diff_item.op] = diff_item
+
+    filtered_diff = []
+    for diff_item in diff:
+        username, mode = _local_user_row_key(diff_item.row)
+        if username and mode:
+            ops = set(grouped[(username, mode)])
+            # NOCDEVDUTY-1786 делаем так чтобы в генераторе не требовалось точно попасть в порядок service-type
+            # у хуавей порядок аргументов в данном месте меняется в зависимости от версии софта
+            # при этом команда принимается в любом виде, меняется отображение в конфиге, вводить ее можно как угодно
+            # поэтому если команды local-user * service-type ... совпадают с точностью до перестановки то ничего не правим
+            if mode == "service-type" and ops == {Op.ADDED, Op.REMOVED}:
+                added = set(grouped[(username, mode)][Op.ADDED].row.split())
+                removed = set(grouped[(username, mode)][Op.REMOVED].row.split())
+                if added == removed:
+                    continue
+
+        filtered_diff.append(diff_item)
+
+    return filtered_diff
+
+
+def _local_user_row_key(row):
+    username, mode = None, None
+    splitted_row = row.split()
+    # Ожидаемый формат команды 'local-user <username> <mode> ...'
+    if splitted_row and splitted_row[0] == "local-user":
+        if len(splitted_row) >= 3:
+            username = splitted_row[1]
+            mode = splitted_row[2]
+    return username, mode

annet/rulebook/huawei/bgp.py

@@ -0,0 +1,97 @@
+import socket
+
+from annet.annlib.types import Op
+
+from annet.rulebook import common
+
+
+def undo_commit(rule, key, diff, **_):
+    # Huawei не даёт снести конфигурацию bgp и написать заново одним коммитом. Говорит:
+    #    Invalid configuration. BGP is under undo.
+    # при попытке создать новую после удаления
+    if diff[Op.REMOVED]:
+        rule["force_commit"] = True
+        yield (False, rule["reverse"], None)
+    # commit нужен под undo bgp
+    rule["force_commit"] = False
+    yield from common.default(rule, key, diff)
+
+
+def peer(rule, key, diff, **_):  # pylint: disable=unused-argument
+    """
+        Особенность peer-команд в том, что
+            peer IP as-number N
+        является основной командой, и отменить её можно только через
+            undo peer IP
+        , то есть полностью удалив все настройки пира.
+
+        При этом, as-number может выставляться и для группы:
+            group SPINES
+            peer SPINES as-number 13238
+        в таком случае игнорим, позволяем удалить эту настройку поскольку она не дефайнит группу
+            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:
+                # мы не можем делать common.default потому что правило определено как peer * а не peer * *
+                # таким образом дефолтное поведение тут будет "undo peer PEERGROUP" что не то что мы хотим
+                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/rulebook/huawei/iface.py

@@ -0,0 +1,33 @@
+import re
+
+from annet.annlib.types import Op
+
+from annet.rulebook import common
+
+
+def permanent(rule, key, diff, **kwargs):  # pylint: disable=redefined-outer-name
+    ifname = key[0]
+    if re.match(r"(Eth-Trunk|Vlanif|Vbdif|Loop[Bb]ack|Tunnel|.*\.\d+)", ifname):
+        # эти интерфейсы можно удалять
+        yield from common.default(rule, key, diff, **kwargs)
+    else:
+        yield from common.permanent(rule, key, diff, **kwargs)
+
+
+# [NOCDEV-2180] Хуавей просит переввести ip конфигурацию после изменения vrf
+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/rulebook/huawei/misc.py

@@ -0,0 +1,337 @@
+import copy
+import re
+from collections import namedtuple
+
+from annet.annlib.types import Op
+from contextlog import get_logger
+
+from annet.rulebook import common
+
+
+class VRPVersion(namedtuple("VRPVersionBase", ["V", "R", "C", "SPC"])):
+    ANY = object()
+    ATTR_NAMES = ["V", "R", "C", "SPC"]
+
+    def __eq__(self, other):
+        if not isinstance(other, type(self)):
+            return False
+
+        for attr_name in self.ATTR_NAMES:
+            self_attr = getattr(self, attr_name)
+            if self_attr is self.ANY:
+                continue
+            other_attr = getattr(other, attr_name)
+            if other_attr is self.ANY:
+                continue
+
+            if self_attr != other_attr:
+                return False
+
+        return True
+
+    def __ne__(self, other):
+        return not self == other
+
+
+def parse_version(version: str) -> VRPVersion:
+    # CP - Cold Patch
+    # HP - Hot Patch
+    if not version:
+        # FIXME: возможно, если в RT нет данных, надо спрашивать у самого устройства?
+        version = "VRP V200R002C50SPC800"
+        get_logger().warning("SW version not set, falling back to %r", version)
+    res = re.match(r"(?:VRP )?V(?P<v>\d+)R(?P<r>\d+)C(?P<c>\d+)(SPC(?P<spc>\d+))?(?P<opt>T)?", version)
+    assert res is not None, f"can't parse version '{version}'"
+    m = res.groupdict()  # pylint: disable=invalid-name
+    return VRPVersion(int(m["v"]), int(m["r"]), int(m["c"] or 0), int(m["spc"] or 0))
+
+
+# =====
+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):
+    # для того чтобы опредилить полностью ли изменяется
+    # префикс лист в рулбуке huawei.rul описан ключ (family, name)
+    # однако с точки зрения команды каждый индекс - отдельная команда
+    # поэтому мы группируем их по индексу тут и передаем в common
+    diff_by_index = {}
+    for op, rows in diff.items():
+        for row in rows:
+            # ожидаемый формат команды префикс-листа
+            # 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]:
+        # поскольку исходно у нас в ключе правила нет индекса
+        # нужно добавить его туда иначе undo-правило будет без оного
+        indexed_rule = copy.deepcopy(rule)
+        indexed_rule["reverse"] = "undo ip {}-prefix {} index {}"
+
+        # stub_index референсится в рулбуке huawei.order чтобы обеспечить
+        # добавление/удаление стаба в первую/последнюю очередь
+        stub, stub_index = "", 99999999
+
+        # если мы только добавляем новые команды (например создаем) в префик-лист
+        # либо удаляем/двигаем но при этом у нас есть не изменяемые части
+        # хуавей не будет считать лист удаляемым и стаб-правило не нужно
+        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, **_):
+    """
+    Для отката статического маршрута фактически необходимо передавать почти все аргументы,
+    кроме различных track ...
+    При этом, аргументов может быть разное количество - опциональный VRF, опциональный интерфейс.
+    Поэтому мы не парсим саму команду, а только удаляем ненужные аргументы.
+    """
+    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 undo_trust(rule, key, diff, hw, **_):
+    """на CE свитчах команда undo trust; на S undo trust *"""
+    if diff[Op.REMOVED]:
+        if hw.Quidway and not hw.S6700:
+            yield False, "undo trust %s" % key, None
+        else:
+            yield False, "undo trust", None
+    else:
+        yield from common.default(rule, key, diff)
+
+
+def port_queue(rule, key, diff, **_):
+    """
+    Для отката конфигурации port-queue на интерфейсе требуется только частичное указание параметров.
+    Пример отключения/включения:
+    interface 100GE0/1/33
+        undo port-queue af3 wfq outbound
+        port-queue af3 wfq weight 30 port-wred WRED outbound
+
+    По сути на убрать все параметры между 'wfq' и '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 old_snmp_iface_trap_undo(rule, key, diff, hw, **_):
+    # хитрая логика для старый хуавеев
+    # тут вместо полной команды с undo нужно сгенерить не полную строку
+    if diff[Op.REMOVED]:
+        if hw.Quidway:
+            yield False, "undo mac-address trap notification", None
+        else:
+            yield False, "undo mac-address trap notification learn", None
+    else:
+        yield from common.default(rule, key, diff)
+
+
+def stelnet(rule, key, diff, **_):
+    # не заменяем строки stelnet ipv4 server enable и stelnet ipv6 server enable на stelnet server enable
+    # чтобы не дергать SSH
+    if diff[Op.REMOVED] and diff[Op.ADDED]:
+        removed = {x["row"] for x in diff[Op.REMOVED]}
+        added = {x["row"] for x in diff[Op.ADDED]}
+        if removed == {"stelnet ipv4 server enable", "stelnet ipv6 server enable"} and added == {"stelnet server enable"}:
+            return
+    yield from common.default(rule, key, diff)
+
+
+def snmpagent_sysinfo_version(rule, key, diff, hw, **_):
+    if hw.Huawei.CE and (diff[Op.ADDED] or diff[Op.REMOVED]):
+        assert len(diff[Op.AFFECTED]) == 0, "WTF? Affected not empty: %r" % (diff[Op.AFFECTED])
+        versions = set(["v1", "v2c", "v3"])
+
+        result = set()
+        for op in [Op.REMOVED, Op.ADDED]:
+            for action in diff[op]:
+                args = action["row"].split()[3:]
+                assert len(args) > 0, "Empty op %r: %r" % (op, action["row"])
+
+                if args[-1] == "disable":
+                    args = args[:-1]
+                    disable = True
+                else:
+                    disable = False
+                if "all" in args:
+                    args = versions
+                else:
+                    assert len(set(args).difference(versions)) == 0, "Incorrect args: %r" % (args)
+
+                if (op == Op.REMOVED and disable) or (op == Op.ADDED and not disable):
+                    result.update(args)
+                else:
+                    result.difference_update(args)
+
+        if result == versions:
+            yield (True, "snmp-agent sys-info version all", None)
+        else:
+            yield (False, "snmp-agent sys-info version all disable", None)
+            yield (True, "snmp-agent sys-info version %s" % (" ".join(result)), None)
+    else:
+        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, **_):
+    # если type меняется нужно сначала удалить все if-match
+    # а после этого пересоздать 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)
+
+    # Приходится самим говорить undo поскольку мы притворяемся одним блоком
+    for subdiff in diff[Op.REMOVED]:
+        # Сначала нужно удалить все group-member'ы
+        if diff[Op.REMOVED][0]["children"]:
+            yield (True, diff[Op.REMOVED][0]["row"], diff[Op.REMOVED][0]["children"])
+        yield False, "undo " + subdiff["row"], None
+    # Сначала разбираем affected, там внутри могут быть 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, **_):
+    # Для ряда конфигурационных строк возникает вечный diff, поскольку в конфиге строка либо явно включена,
+    # либо явно выключена. Если она не описана в генераторе, т.е. мы полагаемся на дефолт, то используя clear
+    # вместо undo мы возвращаем конфиг в дефолтное состояние.
+    # 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)

annet/rulebook/huawei/vlandb.py

@@ -0,0 +1,115 @@
+from annet.annlib.lib import huawei_collapse_vlandb as collapse_vlandb
+from annet.annlib.lib import huawei_expand_vlandb as expand_vlandb
+from annet.annlib.types import Op
+
+from annet.rulebook import common
+from annet.rulebook.common import DiffItem
+
+
+# =====
+def single(rule, key, diff, **_):
+    yield from _process_vlandb(rule, key, diff, False, False, None)
+
+
+def multi(rule, key, diff, **_):
+    yield from _process_vlandb(rule, key, diff, True, False, 10)
+
+
+def multi_all(rule, key, diff, **_):
+    yield from _process_vlandb(rule, key, diff, True, True, 10)
+
+
+def vlan_diff(old, new, diff_pre, _pops):
+    batch_new = set()  # vlan batch ... vlan ids
+    for row in new:
+        prefix, vlans = _parse_vlancfg(row)
+        if prefix == "vlan batch":
+            batch_new.update(vlans)
+    ret = []
+    for item in common.default_diff(old, new, diff_pre, _pops):
+        prefix, vlan_ids = _parse_vlancfg(item.row)
+        # если влан был объявлен глобально и при этом остается в батче
+        # команда undo vlan ... будет пытаться полностью выпилить его с устройства
+        # и из батча тоже. при этом делать undo vlan ... ; vlan batch ... не выход
+        # поскольку для удаления cli требует удалить все vlanif"ы и проч
+        if prefix == "vlan" and item.op == Op.REMOVED and batch_new.intersection(vlan_ids):
+            result_item = DiffItem(Op.AFFECTED, item.row, item.children, item.diff_pre)
+        # если влан объявлен глобально и одновременно с этим в батче
+        # и при этом в блоке глобального объявления нет никаких опций
+        # не добавляем его он будет висеть зазря - таким образом мы сохраним
+        # симметрию с предыдущей логикой оба инварианта будут выдавать пустой патч
+        elif prefix == "vlan" and batch_new.intersection(vlan_ids) and not item.children:
+            result_item = None
+        # vlan batch и остальное мы не трогаем
+        else:
+            result_item = item
+        if result_item:
+            ret.append(result_item)
+    return ret
+
+
+# =====
+def _process_vlandb(rule, key, diff, multi, multi_all, multi_chunk):  # pylint: disable=unused-argument,redefined-outer-name
+    assert len(diff[Op.AFFECTED]) == 0, "WTF? Affected signle: %r" % (diff[Op.AFFECTED])
+    if not multi:
+        for op in (Op.ADDED, Op.REMOVED):
+            assert 0 <= len(diff[op]) <= 1, "Too many actions: %r" % (diff)
+
+    if diff[Op.REMOVED] and not diff[Op.ADDED]:  # Removed
+        if multi and multi_all:
+            yield (False, rule["reverse"].format(*key) + " all", None)
+            return
+        elif not multi and not multi_all:
+            yield (False, rule["reverse"].format(*key), None)
+            return
+
+    (prefix_add, new) = _parse_vlancfg_actions(diff[Op.ADDED])
+    (prefix_del, old) = _parse_vlancfg_actions(diff[Op.REMOVED])
+    removed = old.difference(new)
+    added = new.difference(old)
+
+    if removed:
+        collapsed = collapse_vlandb(removed)
+        for chunk in (_chunked(collapsed, multi_chunk) if multi else [collapsed]):
+            yield (False, "undo %s %s" % (prefix_del, " ".join(chunk)), None)
+
+    if added:
+        collapsed = collapse_vlandb(added)
+        for chunk in (_chunked(collapsed, multi_chunk) if multi else [collapsed]):
+            yield (True, "%s %s" % (prefix_add, " ".join(chunk)), None)
+
+
+def _chunked(items, size):
+    for offset in range(0, len(items), size):
+        yield items[offset:offset + size]
+
+
+def _parse_vlancfg_actions(actions):
+    prefix = None
+    vlandb = set()
+    for action in actions:
+        (prefix, part) = _parse_vlancfg(action["row"])
+        vlandb.update(part)
+    return (prefix, vlandb)
+
+
+def _parse_vlancfg(row):
+    parts = row.split()
+    assert len(parts) > 0, row
+    index = None
+    for (index, item) in reversed(list(enumerate(parts))):
+        if not (item.isdigit() or item == "to"):
+            break
+    prefix = " ".join(parts[:index + 1])
+    vlandb = expand_vlandb(" ".join(parts[index + 1:]))
+    return (prefix, vlandb)
+
+
+def _find_new_vlans(root_pre):
+    ret = set()
+    for (rule, pre) in root_pre.items():
+        if not rule.startswith("vlan batch"):
+            continue
+        new = _parse_vlancfg_actions(pre["items"][tuple()][Op.ADDED])[1]
+        ret.update(new)
+    return ret