xmlbuilder: Add explicit support for refreshing an XML prop

virtinst/VirtualDisk.py

@@ -400,7 +400,6 @@ class VirtualDisk(VirtualDevice):
         self._storage_backend = diskbackend.StorageBackend(self.conn,
                                                            None, None, None)
         self._storage_creator = None
-        self._override_default = True
 
         self.nomanaged = False
         self.transient = False
@@ -443,8 +442,7 @@ class VirtualDisk(VirtualDevice):
             return self._type
         return self._get_default_type()
     def set_type(self, val):
-        if self._override_default:
-            self._type = val
+        self._type = val
     type = XMLProperty(get_type, set_type,
                          xpath="./@type")
 
@@ -466,8 +464,7 @@ class VirtualDisk(VirtualDevice):
             return self._driverName
         return self._get_default_driver()[0]
     def set_driver_name(self, val):
-        if self._override_default:
-            self._driverName = val
+        self._driverName = val
     driver_name = XMLProperty(get_driver_name, set_driver_name,
                                 xpath="./driver/@name")
 
@@ -476,8 +473,7 @@ class VirtualDisk(VirtualDevice):
             return self._driverType
         return self._get_default_driver()[1]
     def set_driver_type(self, val):
-        if self._override_default:
-            self._driverType = val
+        self._driverType = val
     driver_type = XMLProperty(get_driver_type, set_driver_type,
                                 xpath="./driver/@type")
 
@@ -599,14 +595,9 @@ class VirtualDisk(VirtualDevice):
                                 path, vol_object, None, None)
         self._storage_backend = backend
 
-        if self._is_parse():
-            try:
-                self._override_default = False
-                self.type = self.type
-                self.driver_name = self.driver_name
-                self.driver_type = self.driver_type
-            finally:
-                self._override_default = True
+        self.refresh_xml_prop("type")
+        self.refresh_xml_prop("driver_name")
+        self.refresh_xml_prop("driver_type")
 
     def _get_default_type(self):
         if self._storage_creator:

virtinst/xmlbuilder.py

@@ -316,14 +316,12 @@ class XMLProperty(property):
                 return key
         raise RuntimeError("Didn't find expected property")
 
-    def _default_orig_fset(self, xmlbuilder, val, *args, **kwargs):
+    def _default_orig_fset(self, xmlbuilder, val):
         """
         If no fset specified, this stores the value in XMLBuilder._propstore
         dict as propname->value. This saves us from having to explicitly
         track every variable.
         """
-        ignore = args
-        ignore = kwargs
         propstore = getattr(xmlbuilder, "_propstore")
         proporder = getattr(xmlbuilder, "_proporder")
 
@@ -336,13 +334,11 @@ class XMLProperty(property):
             proporder.remove(propname)
         proporder.append(propname)
 
-    def _default_orig_fget(self, xmlbuilder, *args, **kwargs):
+    def _default_orig_fget(self, xmlbuilder):
         """
         The flip side to default_orig_fset, fetch the value from
         XMLBuilder._propstore
         """
-        ignore = args
-        ignore = kwargs
         propstore = getattr(xmlbuilder, "_propstore")
         return propstore.get(self._findpropname(xmlbuilder), None)
 
@@ -420,8 +416,8 @@ class XMLProperty(property):
             return bool(val)
         return val
 
-    def new_getter(self, xmlbuilder, *args, **kwargs):
-        fgetval = self._orig_fget(xmlbuilder, *args, **kwargs)
+    def new_getter(self, xmlbuilder):
+        fgetval = self._orig_fget(xmlbuilder)
 
         root_node = getattr(xmlbuilder, "_xml_node")
         if root_node is None:
@@ -454,9 +450,9 @@ class XMLProperty(property):
         return fgetval
 
 
-    def new_setter(self, xmlbuilder, val, *args, **kwargs):
-        # Do this regardless, for validation purposes
-        self._orig_fset(xmlbuilder, val, *args, **kwargs)
+    def new_setter(self, xmlbuilder, val, local=True):
+        if local:
+            self._orig_fset(xmlbuilder, val)
 
         root_node = getattr(xmlbuilder, "_xml_node")
         if root_node is None:
@@ -489,6 +485,9 @@ class XMLProperty(property):
             else:
                 _remove_xpath_node(root_node, use_xpath)
 
+    def refresh_xml(self, xmlbuilder):
+        self.fset(xmlbuilder, self.fget(xmlbuilder), local=False)
+
 
 class XMLBuilder(object):
     """
@@ -597,6 +596,13 @@ class XMLBuilder(object):
     def set_defaults(self):
         pass
 
+    def refresh_xml_prop(self, propname):
+        """
+        Refresh the XML for the passed class propname. Used to adjust
+        the XML when an interdependent property changes.
+        """
+        getattr(self.__class__, propname).refresh_xml(self)
+
     def _get_xml_config(self):
         """
         Internal XML building function. Must be overwritten by subclass