From 7250fe0521ccb77e73563a0a36d23cac81956457 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 29 Jul 2011 07:05:27 -0700
Subject: added instance support to to_primitive and tests

---
 nova/utils.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova/utils.py')

diff --git a/nova/utils.py b/nova/utils.py
index 8784a227d..f54bf72ed 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -521,6 +521,9 @@ def to_primitive(value):
         return to_primitive(dict(value.iteritems()))
     elif hasattr(value, '__iter__'):
         return to_primitive(list(value))
+    elif hasattr(value, '__dict__'):
+        # Class member variables not supported.
+        return to_primitive(value.__dict__)
     else:
         return value
 
-- 
cgit 


From 51f4d4c2e0c7d9f066b328014aa955b150b62c3a Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 29 Jul 2011 12:09:17 -0700
Subject: made the whole instance handling thing optional

---
 nova/utils.py | 77 ++++++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 55 insertions(+), 22 deletions(-)

(limited to 'nova/utils.py')

diff --git a/nova/utils.py b/nova/utils.py
index f54bf72ed..1a04c471c 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -504,28 +504,61 @@ def utf8(value):
     return value
 
 
-def to_primitive(value):
-    if type(value) is type([]) or type(value) is type((None,)):
-        o = []
-        for v in value:
-            o.append(to_primitive(v))
-        return o
-    elif type(value) is type({}):
-        o = {}
-        for k, v in value.iteritems():
-            o[k] = to_primitive(v)
-        return o
-    elif isinstance(value, datetime.datetime):
-        return str(value)
-    elif hasattr(value, 'iteritems'):
-        return to_primitive(dict(value.iteritems()))
-    elif hasattr(value, '__iter__'):
-        return to_primitive(list(value))
-    elif hasattr(value, '__dict__'):
-        # Class member variables not supported.
-        return to_primitive(value.__dict__)
-    else:
-        return value
+def to_primitive(value, convert_instances=False, level=0):
+    """Convert a complex object into primitives.
+
+    Handy for JSON serialization. We can optionally handle instances,
+    but since this is a recursive function, we could have cyclical
+    data structures.
+
+    To handle cyclical data structures we could track the actual objects
+    visited in a set, but not all objects are hashable. Instead we just
+    track the depth of the object inspections and don't go too deep.
+
+    Therefore, convert_instances=True is lossy ... be aware.
+
+    """
+    if inspect.isclass(value):
+        return unicode(value)
+
+    if level > 3:
+        return []
+
+    # The try block may not be necessary after the class check above,
+    # but just in case ...
+    try:
+        if type(value) is type([]) or type(value) is type((None,)):
+            o = []
+            for v in value:
+                o.append(to_primitive(v, convert_instances=convert_instances,
+                                      level=level))
+            return o
+        elif type(value) is type({}):
+            o = {}
+            for k, v in value.iteritems():
+                o[k] = to_primitive(v, convert_instances=convert_instances,
+                                    level=level)
+            return o
+        elif isinstance(value, datetime.datetime):
+            return str(value)
+        elif hasattr(value, 'iteritems'):
+            return to_primitive(dict(value.iteritems()),
+                                convert_instances=convert_instances,
+                                level=level)
+        elif hasattr(value, '__iter__'):
+            return to_primitive(list(value), level)
+        elif convert_instances and hasattr(value, '__dict__'):
+            # Likely an instance of something. Watch for cycles.
+            # Ignore class member vars.
+            return to_primitive(value.__dict__,
+                                convert_instances=convert_instances,
+                                level=level + 1)
+        else:
+            return value
+    except TypeError, e:
+        # Class objects are tricky since they may define something like
+        # __iter__ defined but it isn't callable as list().
+        return unicode(value)
 
 
 def dumps(value):
-- 
cgit