Add a Kubernetes specific recursive dict diff

Understands strategic patch keys and can therefore
better diff list elements

Author: willthames

openshift/dynamic/apply.py

@@ -183,6 +183,60 @@ def list_merge(last_applied, actual, desired, position):
         return desired
 
 
+def recursive_list_diff(list1, list2, position=None):
+    result = (list(), list())
+    if position in STRATEGIC_MERGE_PATCH_KEYS:
+        patch_merge_key = STRATEGIC_MERGE_PATCH_KEYS[position]
+        dict1 = list_to_dict(list1, patch_merge_key, position)
+        dict2 = list_to_dict(list2, patch_merge_key, position)
+        for key in dict1.keys() - dict2.keys():
+            result[0].append(dict1[key])
+        for key in dict2.keys() - dict1.keys():
+            result[1].append(dict2[key])
+        for key in dict1.keys() & dict2.keys():
+            diff = recursive_diff(dict1[key], dict2[key], position)
+            if diff:
+                # reinsert patch merge key to relate changes in other keys to
+                # a specific list element
+                diff[0].update({patch_merge_key: dict1[key][patch_merge_key]})
+                diff[1].update({patch_merge_key: dict2[key][patch_merge_key]})
+                result[0].append(diff[0])
+                result[1].append(diff[1])
+        if result[0] or result[1]:
+            return result
+    elif list1 != list2:
+        return (list1, list2)
+    return None
+
+
+def recursive_diff(dict1, dict2, position=None):
+    if not position:
+        if 'kind' in dict1 and dict1.get('kind') == dict2.get('kind'):
+            position = dict1['kind']
+    left = dict((k, v) for (k, v) in dict1.items() if k not in dict2)
+    right = dict((k, v) for (k, v) in dict2.items() if k not in dict1)
+    for k in (set(dict1.keys()) & set(dict2.keys())):
+        if position:
+            this_position = "%s.%s" % (position, k)
+        if isinstance(dict1[k], dict) and isinstance(dict2[k], dict):
+            result = recursive_diff(dict1[k], dict2[k], this_position)
+            if result:
+                left[k] = result[0]
+                right[k] = result[1]
+        elif isinstance(dict1[k], list) and isinstance(dict2[k], list):
+            result = recursive_list_diff(dict1[k], dict2[k], this_position)
+            if result:
+                left[k] = result[0]
+                right[k] = result[1]
+        elif dict1[k] != dict2[k]:
+            left[k] = dict1[k]
+            right[k] = dict2[k]
+    if left or right:
+        return left, right
+    else:
+        return None
+
+
 def get_deletions(last_applied, desired):
     patch = {}
     for k, last_applied_value in last_applied.items():

test/unit/test_diff.py

@@ -0,0 +1,69 @@
+from openshift.dynamic.apply import recursive_diff
+
+tests = [
+    dict(
+        before = dict(
+            kind="Service",
+            metadata=dict(name="foo"),
+            spec=dict(ports=[dict(port=8080, name="http")])
+        ),
+        after = dict(
+            kind="Service",
+            metadata=dict(name="foo"),
+            spec=dict(ports=[dict(port=8080, name="http")])
+        ),
+        expected = None
+    ),
+    dict(
+        before = dict(
+            kind="Service",
+            metadata=dict(name="foo"),
+            spec=dict(ports=[dict(port=8080, name="http")])
+        ),
+        after = dict(
+            kind="Service",
+            metadata=dict(name="foo"),
+            spec=dict(ports=[dict(port=8081, name="http")])
+        ),
+        expected = (
+            dict(spec=dict(ports=[dict(port=8080, name="http")])),
+            dict(spec=dict(ports=[dict(port=8081, name="http")]))
+        )
+    ),
+    dict(
+        before = dict(
+            kind="Service",
+            metadata=dict(name="foo"),
+            spec=dict(ports=[dict(port=8080, name="http"), dict(port=8081, name="https")])
+        ),
+        after = dict(
+            kind="Service",
+            metadata=dict(name="foo"),
+            spec=dict(ports=[dict(port=8081, name="https"), dict(port=8080, name="http")])
+        ),
+        expected = None
+    ),
+
+    dict(
+        before = dict(
+            kind="Pod",
+            metadata=dict(name="foo"),
+            spec=dict(containers=[dict(name="busybox", image="busybox",
+                                       env=[dict(name="hello", value="world"),
+                                            dict(name="another", value="next")])])
+        ),
+        after = dict(
+            kind="Pod",
+            metadata=dict(name="foo"),
+            spec=dict(containers=[dict(name="busybox", image="busybox",
+                                       env=[dict(name="hello", value="everyone")])])
+        ),
+        expected=(dict(spec=dict(containers=[dict(name="busybox", env=[dict(name="another", value="next"), dict(name="hello", value="world")])])),
+                  dict(spec=dict(containers=[dict(name="busybox", env=[dict(name="hello", value="everyone")])])))
+    ),
+    ]
+
+
+def test_diff():
+    for test in tests:
+        assert(recursive_diff(test['before'], test['after']) == test['expected'])