data: add diff support

This patch adds support for the `lyd_diff` function.

Signed-off-by: Annika Hannig <annika@hannig.cc>

Author: annikahannig

cffi/cdefs.h

@@ -410,6 +410,9 @@ typedef enum {
 #define LYD_OPT_DESTRUCT ...
 #define LYD_OPT_NOSIBLINGS ...
 
+#define LYD_DIFFOPT_NOSIBLINGS ...
+#define LYD_DIFFOPT_WITHDEFAULTS ...
+
 typedef union lyd_value_u {
 	int8_t bln;
 	struct lyd_node *leafref;
@@ -434,6 +437,23 @@ struct lyd_node_leaf_list {
 	...;
 };
 
+typedef enum {
+    LYD_DIFF_END,
+    LYD_DIFF_DELETED,
+    LYD_DIFF_CHANGED,
+    LYD_DIFF_MOVEDAFTER1,
+    LYD_DIFF_CREATED,
+    LYD_DIFF_MOVEDAFTER2,
+    ...
+} LYD_DIFFTYPE;
+
+struct lyd_difflist {
+    LYD_DIFFTYPE *type;
+    struct lyd_node **first;
+    struct lyd_node **second;
+    ...;
+};
+
 struct ly_set *lyd_find_instance(const struct lyd_node *, const struct lys_node *);
 struct ly_set *lyd_find_path(const struct lyd_node *, const char *);
 struct lyd_node *lyd_new(struct lyd_node *, const struct lys_module *, const char *);
@@ -454,6 +474,8 @@ void lyd_free(struct lyd_node *);
 void lyd_free_withsiblings(struct lyd_node *);
 int lyd_validate(struct lyd_node **, int, void *);
 int lyd_merge(struct lyd_node *, const struct lyd_node *, int);
+struct lyd_difflist *lyd_diff(struct lyd_node *first, struct lyd_node *second, int options);
+void lyd_free_diff(struct lyd_difflist *diff);
 
 /* from libc, needed to free allocated strings */
 void free(void *);

libyang/__init__.py

@@ -4,7 +4,7 @@
 
 
 from .context import Context
-from .data import DContainer, DLeaf, DLeafList, DList, DNode, DRpc
+from .data import DContainer, DDiff, DLeaf, DLeafList, DList, DNode, DRpc
 from .diff import (
     BaseTypeAdded,
     BaseTypeRemoved,
@@ -90,6 +90,7 @@
     "ConfigFalseRemoved",
     "Context",
     "DContainer",
+    "DDiff",
     "DLeaf",
     "DLeafList",
     "DList",

libyang/data.py

@@ -110,6 +110,63 @@ def parser_flags(
     return flags
 
 
+def diff_flags(
+    with_defaults: bool = False,
+    no_siblings: bool = False,
+) -> int:
+    flags = 0
+    if with_defaults:
+        flags |= lib.LYD_DIFFOPT_WITHDEFAULTS
+    if no_siblings:
+        flags |= lib.LYD_DIFFOPT_NOSIBLINGS
+    return flags
+
+
+# -------------------------------------------------------------------------------------
+class DDiff:
+    """
+    Data tree diff
+    """
+
+    DELETED = lib.LYD_DIFF_DELETED
+    CHANGED = lib.LYD_DIFF_CHANGED
+    CREATED = lib.LYD_DIFF_CREATED
+    MOVEDAFTER1 = lib.LYD_DIFF_MOVEDAFTER1
+    MOVEDAFTER2 = lib.LYD_DIFF_MOVEDAFTER2
+
+    DIFF_TYPES = {
+        DELETED: "deleted",
+        CHANGED: "changed",
+        CREATED: "created",
+        MOVEDAFTER1: "movedafter1",
+        MOVEDAFTER2: "movedafter2",
+    }
+
+    __slots__ = ("dtype", "first", "second")
+
+    def __init__(self, dtype, first: Optional["DNode"], second: Optional["DNode"]):
+        """
+        :arg dtype:
+            The type of the diff
+        :arg first:
+            The first DNode
+        :arg second:
+            The second DNode
+        """
+        self.dtype = dtype
+        self.first = first
+        self.second = second
+
+    def diff_type(self) -> str:
+        """Get diff type as string"""
+        return self.DIFF_TYPES.get(self.dtype, "unknown")
+
+    def __repr__(self) -> str:
+        return "<libyang.data.DDiff {} first={} second={}>".format(
+            self.diff_type(), self.first, self.second
+        )
+
+
 # -------------------------------------------------------------------------------------
 class DNode:
     """
@@ -224,6 +281,31 @@ def validate(
         if ret != 0:
             raise self.context.error("validation failed")
 
+    def diff(
+        self,
+        other: "DNode",
+        no_siblings: bool = False,
+        with_defaults: bool = False,
+    ) -> Iterator[DDiff]:
+        flags = diff_flags(no_siblings=no_siblings, with_defaults=with_defaults)
+        dlist = lib.lyd_diff(self.cdata, other.cdata, flags)
+        if not dlist:
+            raise self.context.error("diff failed")
+
+        i = 0
+        try:
+            while dlist.type[i] != lib.LYD_DIFF_END:
+                first = None
+                if dlist.first[i]:
+                    first = self.new(self.context, dlist.first[i])
+                second = None
+                if dlist.second[i]:
+                    second = self.new(self.context, dlist.second[i])
+                yield DDiff(dlist.type[i], first, second)
+                i += 1
+        finally:
+            lib.lyd_free_diff(dlist)
+
     def merge(
         self,
         source: "DNode",

tests/test_data.py

@@ -7,7 +7,7 @@
 from unittest.mock import patch
 
 from _libyang import lib
-from libyang import Context, DContainer, DRpc, LibyangError
+from libyang import Context, DContainer, DDiff, DRpc, LibyangError
 
 
 YANG_DIR = os.path.join(os.path.dirname(__file__), "yang")
@@ -489,3 +489,79 @@ def test_data_to_dict_action(self):
                 },
             },
         )
+
+    XML_DIFF_STATE1 = """<state xmlns="urn:yang:yolo:system">
+  <hostname>foo</hostname>
+  <speed>1234</speed>
+  <number>1000</number>
+  <number>2000</number>
+  <number>3000</number>
+  <url>
+    <proto>https</proto>
+    <host>github.com</host>
+    <path>/CESNET/libyang-python</path>
+    <enabled>false</enabled>
+  </url>
+  <url>
+    <proto>http</proto>
+    <host>foobar.com</host>
+    <port>8080</port>
+    <path>/index.html</path>
+    <enabled>true</enabled>
+  </url>
+</state>
+"""
+    XML_DIFF_STATE2 = """<state xmlns="urn:yang:yolo:system">
+  <hostname>foo</hostname>
+  <speed>5432</speed>
+  <number>1000</number>
+  <number>3000</number>
+  <url>
+    <proto>https</proto>
+    <host>github.com</host>
+    <path>/CESNET/libyang-python</path>
+    <enabled>true</enabled>
+  </url>
+  <url>
+    <proto>http</proto>
+    <host>foobar.com</host>
+    <port>8080</port>
+    <path>/index.html</path>
+    <enabled>false</enabled>
+  </url>
+  <url>
+    <proto>ftp</proto>
+    <host>github.com</host>
+    <path>/CESNET/libyang-python</path>
+    <enabled>false</enabled>
+  </url>
+</state>
+"""
+
+    def test_data_diff(self):
+        dnode1 = self.ctx.parse_data_mem(
+            self.XML_DIFF_STATE1, "xml", data=True, no_yanglib=True
+        )
+        self.assertIsInstance(dnode1, DContainer)
+        dnode2 = self.ctx.parse_data_mem(
+            self.XML_DIFF_STATE2, "xml", data=True, no_yanglib=True
+        )
+        self.assertIsInstance(dnode2, DContainer)
+
+        diffs = dnode1.diff(dnode2)
+        diffs_result = [
+            (diff.dtype, diff.first.name(), diff.second.name() if diff.second else None)
+            for diff in diffs
+        ]
+        expected = [
+            (DDiff.CHANGED, "speed", "speed"),
+            (DDiff.CHANGED, "enabled", "enabled"),
+            (DDiff.CHANGED, "enabled", "enabled"),
+            (DDiff.DELETED, "number", None),
+            (DDiff.CREATED, "state", "url"),
+        ]
+
+        self.assertListEqual(diffs_result, expected)
+
+        dnode1.free()
+        dnode2.free()