Skip to contentSkip to conversation

event_match: always match on None value

PATCH Superseded John Snow 2 participants 3 messages May 24, 2019 – May 28, 2019

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

John Snow

author
#0 lore raw

PATCH 1/1 event_match: always match on None value

Before, event_match didn't always recurse if the event value was not a dictionary, and would instead check for equality immediately.

By delaying equality checking to post-recursion, we can allow leaf values like "5" to match "None" and take advantage of the generic None-returns-True clause.

This makes the matching a little more obviously consistent at the expense of being able to check for explicit None values, which is probably not that important given what this function is used for.

---
 python/qemu/__init__.py | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)
python/qemu/__init__.py +15 -12
index 98ed8a2e28..77d45f88fe 100644
@@ -409,27 +409,30 @@ class QEMUMachine(object):
 
         The match criteria takes the form of a matching subdict. The event is
         checked to be a superset of the subdict, recursively, with matching
-        values whenever those values are not None.
+        values whenever the subdict values are not None.
+
+        This has a limitation that you cannot explicitly check for None values.
 
         Examples, with the subdict queries on the left:
          - None matches any object.
          - {"foo": None} matches {"foo": {"bar": 1}}
-         - {"foo": {"baz": None}} does not match {"foo": {"bar": 1}}
-         - {"foo": {"baz": 2}} matches {"foo": {"bar": 1, "baz": 2}}
+         - {"foo": None} matches {"foo": 5}
+         - {"foo": {"abc": None}} does not match {"foo": {"bar": 1}}
+         - {"foo": {"rab": 2}} matches {"foo": {"bar": 1, "rab": 2}}
         """
         if match is None:
             return True
 
-        for key in match:
-            if key in event:
-                if isinstance(event[key], dict):
-                    if not QEMUMachine.event_match(event[key], match[key]):
-                        return False
-                elif event[key] != match[key]:
+        try:
+            for key in match:
+                if key in event:
+                    return QEMUMachine.event_match(event[key], match[key])
+                else:
                     return False
-            else:
-                return False
-        return True
+            return True
+        except TypeError:
+            # either match or event wasn't iterable (not a dict)
+            return match == event
 
     def event_wait(self, name, timeout=60.0, match=None):
         """
Signature · 1 line
2.20.1
#1 lore raw
Quoted 41 lines · John Snow

Before, event_match didn't always recurse if the event value was not a dictionary, and would instead check for equality immediately.

By delaying equality checking to post-recursion, we can allow leaf values like "5" to match "None" and take advantage of the generic None-returns-True clause.

This makes the matching a little more obviously consistent at the expense of being able to check for explicit None values, which is probably not that important given what this function is used for.

---
 python/qemu/__init__.py | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)
python/qemu/__init__.py +6 -3
index 98ed8a2e28..77d45f88fe 100644
@@ -409,27 +409,30 @@ class QEMUMachine(object):
 
         The match criteria takes the form of a matching subdict. The event is
         checked to be a superset of the subdict, recursively, with matching
-        values whenever those values are not None.
+        values whenever the subdict values are not None.
+
+        This has a limitation that you cannot explicitly check for None values.
 
         Examples, with the subdict queries on the left:
          - None matches any object.
          - {"foo": None} matches {"foo": {"bar": 1}}
-         - {"foo": {"baz": None}} does not match {"foo": {"bar": 1}}
-         - {"foo": {"baz": 2}} matches {"foo": {"bar": 1, "baz": 2}}
+         - {"foo": None} matches {"foo": 5}
+         - {"foo": {"abc": None}} does not match {"foo": {"bar": 1}}
+         - {"foo": {"rab": 2}} matches {"foo": {"bar": 1, "rab": 2}}
         """
         if match is None:
             return True
 

python/qemu/__init__.py class QEMUMachine(object): · line 429

Quoted 10 lines
python/qemu/__init__.py +4 -6
-        for key in match:
-            if key in event:
-                if isinstance(event[key], dict):
-                    if not QEMUMachine.event_match(event[key], match[key]):
-                        return False
-                elif event[key] != match[key]:
+        try:
+            for key in match:
+                if key in event:
+                    return QEMUMachine.event_match(event[key], match[key])

With this change, we only check a single key that is both in @match and @event. I think we want to keep the "if not -- return False" pattern, don’t we?

Max

Quoted 13 lines
python/qemu/__init__.py +5 -3
+                else:
                     return False
-            else:
-                return False
-        return True
+            return True
+        except TypeError:
+            # either match or event wasn't iterable (not a dict)
+            return match == event
 
     def event_wait(self, name, timeout=60.0, match=None):
         """
author
#2 lore raw
Quoted 57 lines · Max Reitz
Quoted 41 lines · John Snow

Before, event_match didn't always recurse if the event value was not a dictionary, and would instead check for equality immediately.

By delaying equality checking to post-recursion, we can allow leaf values like "5" to match "None" and take advantage of the generic None-returns-True clause.

This makes the matching a little more obviously consistent at the expense of being able to check for explicit None values, which is probably not that important given what this function is used for.

---
 python/qemu/__init__.py | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)
python/qemu/__init__.py +6 -3
index 98ed8a2e28..77d45f88fe 100644
@@ -409,27 +409,30 @@ class QEMUMachine(object):
 
         The match criteria takes the form of a matching subdict. The event is
         checked to be a superset of the subdict, recursively, with matching
-        values whenever those values are not None.
+        values whenever the subdict values are not None.
+
+        This has a limitation that you cannot explicitly check for None values.
 
         Examples, with the subdict queries on the left:
          - None matches any object.
          - {"foo": None} matches {"foo": {"bar": 1}}
-         - {"foo": {"baz": None}} does not match {"foo": {"bar": 1}}
-         - {"foo": {"baz": 2}} matches {"foo": {"bar": 1, "baz": 2}}
+         - {"foo": None} matches {"foo": 5}
+         - {"foo": {"abc": None}} does not match {"foo": {"bar": 1}}
+         - {"foo": {"rab": 2}} matches {"foo": {"bar": 1, "rab": 2}}
         """
         if match is None:
             return True
 

python/qemu/__init__.py class QEMUMachine(object): · line 429

Quoted 10 lines
python/qemu/__init__.py +4 -6
-        for key in match:
-            if key in event:
-                if isinstance(event[key], dict):
-                    if not QEMUMachine.event_match(event[key], match[key]):
-                        return False
-                elif event[key] != match[key]:
+        try:
+            for key in match:
+                if key in event:
+                    return QEMUMachine.event_match(event[key], match[key])

With this change, we only check a single key that is both in @match and @event. I think we want to keep the "if not -- return False" pattern, don’t we?

Quoted 2 lines

Max

Whoops, way too fast on the send button. Sorry about that.