Changeset 28 for trunk/confloader.py

Timestamp:

26/11/07 20:14:17 (4 years ago)

Author:

daedalus

Message:

* Refactored code to permit more flexible templating of changes. You can now

define a <changetemplate/> in 95% the same way as a <change/>, and then
refer to a <changetemplate/> when defining a <change/> to allow you to
combine change templates as a change flow, using namespaces and iterators
for each one.

* Some work on manual bailout in authoritarian mode, but it isn't completely

bailing out immediately yet, due to some complexities in the deferred chains
that I haven't quite unravelled.

Files:

• trunk/confloader.py (modified) (17 diffs)

trunk/confloader.py

@@ -15 +15 @@
 from device import Device
 from change import CHANGE_STATE
+import util
 
 from twisted.internet import defer, reactor
@@ -128 +129 @@
         self.provisioners = {}
         self.devices = {}
+        self.change_templates = {}
         self.changes = {}
         self.iterators = {}
@@ -163 +165 @@
                     del self.devices[dev]
                     pass
-
-    def oldloader(self):
-        # A new provisioner
-        if name == 'provisioner':
-            log.debug("Creating new provisioner")
-            self.add_provisioner(element)
-
-        elif name == 'device':
-            log.debug("Creating new device")
-            self.add_device(element)
-
-        elif name == 'change':
-            log.debug("Creating new change")
-            self.add_change(element)
-
-        elif name == 'namespace':
-            log.debug("Creating new namespace")
-            self.add_namespace(element)
-
-        elif name == 'config':
-            # We've finished the config
-            #self.global_namespace = self.namespace_stack.pop()
-
-            # Add some global elements to the namespace
-            element.namespace['ALL_TARGETS'] = [ x for x in self.devices.keys() ]
-
-            self.global_namespace = element.namespace
-
-
-##         elif name == 'dependencies':
-##             # We've finish a list of dependency elements
-##             log.info("Finished loaded dependencies.")
-##             self.dependency_tree = element
             
     def parse(self, configfile):
@@ -203 +172 @@
         self.tree = etree.parse(configfile)
 
+        # Process xincludes
+        try:
+            self.tree.xinclude()
+        except etree.XIncludeError:
+            log.error("XInclude of a file failed.")
+            log.error("Use external tool such as xmllint to figure out why.")
+            log.error("Sorry, but lxml.etree won't tell me exactly what went wrong.")
+            raise
+            
         # add the global namespace
         try:
@@ -209 +187 @@
         except IndexError:
             log.warn("Cannot find global namespace")
-            self.global_namespace = None
+            self.global_namespace = {}
 
         # Add all my node types, in the order specified in the list
@@ -216 +194 @@
             'provisioner',
             'device',
+            'changetemplate',
             'change',
-            'dependencies',
+#            'dependencies',
             ]:
 
@@ -333 +312 @@
         log.debug("my ip addr is: %s", device.ipaddress)
         self.devices[device_name] = device
-        
+
+    def add_changetemplate(self, node):
+        """
+        Add a change template to my list of available templates.
+        A change template is a change object that may not have
+        all of its parameters set yet.
+        """
+        log.debug("Adding change template...")
+        # Create the change template object
+        change_tmpl = self.create_change_object(node)
+        
+        # Set any namespaces
+        self.set_change_namespace(change_tmpl, node)
+
+        # Set change parameters that are common to all changes
+        self.set_change_params(change_tmpl, node)
+        
+        # Set the optional change iterator
+        self.set_change_iterator(change_tmpl, node)
+        
+        # Add an optional onfail mode
+        self.set_change_onfail(change_tmpl, node)
+
+        self.change_templates[change_tmpl.name] = change_tmpl
+
+        return change_tmpl
+
     def add_change(self, node):
         """
-        Add a change to my configuration based on the parsed element.
+        When adding a change, check for some extra options such as a
+        change template, which will cause this change to be based on
+        an existing change template.
+        """
+        log.debug("Adding change...")
+        try:
+            tmpl_name = node.attrib['template']
+            log.debug("Change is based on a template: '%s'", tmpl_name)
+            # Do template based processing
+            try:
+                template = self.change_templates[tmpl_name]
+            except KeyError:
+                raise ValueError("Change template '%s' is not defined" % tmpl_name)
+
+            change = template.copy()
+            # Make sure we set the change name to the actual change,
+            # not the name of the template
+            change.name = node.attrib['name']
+
+            # Now do non-templated specific processing
+            self.set_change_namespace(change, node)
+            self.set_change_params(change, node)
+            self.set_change_iterator(change, node)
+            self.set_change_onfail(change, node)
+            
+        except KeyError:
+            # Use the same processing stream as a template, with the
+            # assumption that all the required parameters have been
+            # defined. If they haven't, the change will fail.
+            change = self.add_change_template(node)
+            pass
+        
+        # If the change doesn't have a provisioner, use the first one
+        # in our config by default.
+        if getattr(change, 'provisioner', None) is None:
+            log.info("Change '%s' has no provisioner. Using default.", change.name )
+            # FIXME: This should find the first *compatible* provisioner,
+            # rather than just the first one.
+            change.provisioner = self.provisioners.values()[0]
+            pass
+        
+        self.changes[change.name] = change
+        self.pending_changes.append( change )
+
+    def create_change_object(self, node):
+        """
+        Create a change object from a node.
+        This may be used as a change template, or a regular change.
         """
         # Change type is dynamic, as it supports the loading
@@ -343 +395 @@
         change_name = node.attrib['name']
 
-        log.debug("Attempting to create a '%s' change", change_klass)
+        log.debug("Creating '%s' change", change_klass)
 
         try:
@@ -356 +408 @@
 
         log.debug("created change '%s': %s", change_name, change)
-
-        # Add any namespaces
+        return change
+
+    def set_change_namespace(self, change, node):
+        """
+        Add a namespace to a change or change template
+        """
         ns = node.find('namespace')
         if ns is None:
@@ -364 +420 @@
             self.add_namespace(ns, change)
 
-        # Add change attributes that are common to all changes
+    def set_change_provisioner(self, change, node):
+        # which provisioner to use for the change
+        try:
+            provname = node.attrib['provisioner']
+        except KeyError:
+            return
+        
+        provname = util.substituteVariables(provname, change.namespace)
+        try:
+            change.provisioner = self.provisioners[provname]
+            log.debug("change '%s' will use provisioner '%s'", change, provname)
+        except KeyError:
+            raise KeyError("Provisioner named '%s' is not defined" % provname)
+
+    def set_change_params(self, change, node):
+        """
+        Set common change parameters, defined in subnodes.
+        """
         for subnode in node.xpath('*'):
-            # which provisioner to use for the change
-            if subnode.tag == 'useprov':
-                provname = subnode.text
-                provname = provname % change.namespace
-                change.provisioner = self.provisioners[provname]
-                log.debug("change '%s' will use provisioner '%s'", change, provname)
-                pass
-
             # a target device for the change
-            elif subnode.tag == 'target':
+            if subnode.tag == 'target':
                 targetname = subnode.text
 
@@ -385 +450 @@
                 else:
                     # perform variable substitution with global namespace
-                    #targetname = self.apply_namespaces(targetname)
                     log.debug("my namespace: %s", change.namespace)
-                    targetname = targetname % change.namespace
-                    
+                    targetname = util.substituteVariables(targetname, change.namespace)
                     dev = self.devices[targetname]
                     log.debug("current target list: %s", change.devices)
@@ -395 +458 @@
                 pass
 
-            elif subnode.tag == 'prereq':
-                changename = subnode.text
+            elif subnode.tag == 'depends':
+                changename = subnode.attrib['on']
                 try:
                     change.pre_requisites.append(self.changes[changename])
@@ -444 +507 @@
                 pass
             pass
-
-        # Set the optional change iterator
+        pass
+
+    def set_change_iterator(self, change, node):
+        """
+        Set an optional change iterator
+        """
         try:
             itername = node.attrib['iterator']
@@ -453 +520 @@
         if itername is not None:
             # Use namespace substitution for the itername to allow templating
-            itername = itername % change.namespace
+            itername = util.substituteVariables(itername, change.namespace)
             try:
                 change.iterator = self.iterators[itername]
@@ -460 +527 @@
                 log.error("Iterator '%s' is not defined", itername)
                 raise
-
-        # Add an optional onfail mode
+            pass
+        pass
+
+    def set_change_onfail(self, change, node):
+        """
+        Attempt to add an 'onfail' mode for the change, if defined
+        """
         log.debug("Checking for 'onfail' attribute...")
         try:
@@ -482 +554 @@
             pass
 
-        # If the change doesn't have a provisioner, use the first one
-        # in our config by default.
-        if getattr(change, 'provisioner', None) is None:
-            change.provisioner = self.provisioners.values()[0]
-        
-        self.changes[change_name] = change
-        self.pending_changes.append( change )
 
     def add_namespace(self, node, item=None):
@@ -598 +663 @@
             raise ValueError("change_complete() cannot handle change state: %s", change.state)
 
-    def apply_namespaces(self, string):
-        """
-        Apply namespaces mid parse.
-        Deprecated.
-        """
-        # Find the first namespace in the element stack, and use it,
-        # which will implicitly apply its parents.
-##         tempstack = self.element_stack
-##         tempstack.reverse()
-##         for elem in tempstack:
-##             if getattr(elem, 'namespace', None) is not None:
-##                 log.debug("applying namespace: %s", elem.namespace)
-##                 string = string % elem.namespace
-##                 break
-##             pass
-        log.warn("Inline namespace usage not yet supported.")
+    def _apply_namespace(self, string, namespace):
+        """
+        Apply a namespace to a string
+        Deprecated
+        """
+        if namespace is not None:
+            string = string % namespace
+
         return string