Changeset 28

Timestamp:

26/11/07 20:14:17 (2 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.

Location:

trunk

Files:

• change.py (modified) (2 diffs)
• confloader.py (modified) (17 diffs)
• etc/netapp-provision-demo.xml (modified) (5 diffs)
• provisioner.py (modified) (10 diffs)

trunk/change.py

@@ -215 +215 @@
         return '<%s: %s>' % ( self.__class__, self.name )
 
+    def copy(self):
+        """
+        Create a copy of myself.
+        """
+        newchange = CommandChange('Copy of %s' % self.name,
+                                  self.devices,
+                                  self.serial_mode,
+                                  self.backout_all,
+                                  self.on_fail_continue,
+                                  self.on_fail_retry,
+                                  self.max_retries,
+                                  self.pre_impl,
+                                  self.impl,
+                                  self.post_impl,
+                                  self.pre_backout,
+                                  self.backoutset,
+                                  self.post_backout,
+                                  self.pre_requisites,
+                                  )
+
+        # set the namespace as a copy of mine
+        if self.namespace is not None:
+            newchange.namespace = self.namespace.copy()
+            pass
+
+        return newchange
+        
     def set_state(self, state_string):
         self.state = CHANGE_STATE[state_string]
@@ -236 +263 @@
                 for ns in self.iterator:
                     log.debug("Adding namespace entry of: %s", ns)
-                    # FIXME: This permanently updates the namespace.
-                    # Should we be updating a local copy?
+
+                    # Make sure we only update a copy, so that this
+                    # update isn't permanent
                     newnamespace = ns.copy()
                     newnamespace.update(namespace)

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
 

trunk/etc/netapp-provision-demo.xml

@@ -12 +12 @@
   
 -->
+<!-- include change templates I want to use -->
+<xi:include href="netapp-create-volume.change-template.xml"/>
 
+<!-- define my provisioner -->
 <provisioner
   name='netapp_provisioner'
   type='MultiConnectingProvisioner'
-  command_timeout='5'>
+  command_timeout='30'>
 
   <command>ssh -i /home/daedalus/.ssh/configulator -o BatchMode=yes -o ServerAliveInterval=0 root@%(device.ipaddress)s "%(command.send)s"</command>
@@ -26 +29 @@
 </provisioner>
 
+<!-- define some devices I want to provision to -->
 <device name='wibble'>
   <ipaddress>10.232.8.71</ipaddress>
@@ -34 +38 @@
 </device>
 
-<!-- define some namespace entities that I need for the changes -->
-<namespace>
-  <entry name='primary_filer'>wibble</entry>
-  <entry name='secondary_filer'>wibble</entry>
-
-  <entry name='vfiler_name'>vf_demo</entry>
-
-  <entry name='root_aggr'>aggr01</entry>
-  <entry name='root_vol_size'>20m</entry>
-
-</namespace>
-
-<iterator name="project_volumes">
+<!-- Define iterators used by changes -->
+<iterator name="primary_volumes">
   <dict>
-    <entry name="volnum">00</entry>
+    <entry name="volname">prim_root</entry>
     <entry name="volaggr">aggr01</entry>
     <entry name="volsize">25m</entry>
@@ -54 +47 @@
 
   <dict>
-    <entry name="volnum">01</entry>
+    <entry name="volname">prim_vol01</entry>
     <entry name="volaggr">aggr01</entry>
     <entry name="volsize">25m</entry>
@@ -61 +54 @@
 </iterator>
 
-<change name="create_root_volume_primary" type="CommandChange" onfail='continue'>
+<iterator name="secondary_volumes">
+  <dict>
+    <entry name="volname">sec_root</entry>
+    <entry name="volaggr">aggr01</entry>
+    <entry name="volsize">25m</entry>
+  </dict>
 
-  <target>%(primary_filer)s</target>
+  <dict>
+    <entry name="volname">sec_vol01</entry>
+    <entry name="volaggr">aggr01</entry>
+    <entry name="volsize">25m</entry>
+  </dict>
 
-  <preimpl>
-    <command>
-      <send>vol status %(vfiler_name)s_root</send>
-    </command>
+</iterator>
 
-    <condition>cmdoutput.find("No volume named '%(vfiler_name)s_root' exists.") >= 0</condition>
-
-  </preimpl>
-
-  <impl>
-    <command>
-      <send>vol create %(vfiler_name)s_root %(root_aggr)s %(root_vol_size)s</send>
-    </command>
-
-    <condition>cmdoutput.find("Creation of volume") >= 0</condition>
-    <condition>cmdoutput.find("has completed") >= 0</condition>
-
-  </impl>
-
-  <backout>
-    <command>
-      <send>vol offline %(vfiler_name)s_root</send>
-    </command>
-
-    <command>
-      <expect>Volume '%(vfiler_name)s_root' has been set temporarily offline</expect>
-      <send>vol destroy %(vfiler_name)s_root -f</send>
-    </command>
-
-    <condition>cmdoutput.find("Volume '%(vfiler_name)s_root' destroyed") >= 0</condition>
-
-  </backout>
-
+<!-- Set up the change list I want to apply -->
+<change name="create_primary_volumes" template='create_netapp_volume' iterator='primary_volumes'>
+  <target>wibble</target>
 </change>
 
-<change name="create_project_volume_primary" type="CommandChange" iterator="project_volumes"
-  onfail='retry' max_retries='2'>
-
-  <prereq>create_root_volume_primary</prereq>
-
-  <target>%(primary_filer)s</target>
-
-  <preimpl>
-    <command>
-      <send>vol status %(vfiler_name)s_vol%(volnum)s</send>
-    </command>
-
-    <condition>cmdoutput.find("No volume named '%(vfiler_name)s_vol%(volnum)s' exists.") >= 0</condition>
-
-  </preimpl>
-
-  <impl>
-    <command>
-      <send>vol create %(vfiler_name)s_vol%(volnum)s %(volaggr)s %(volsize)s</send>
-    </command>
-
-    <condition>cmdoutput.find("Creation of volume") >= 0</condition>
-    <condition>cmdoutput.find("has completed") >= 0</condition>
-
-  </impl>
-
-  <backout>
-    <command>
-      <send>vol offline %(vfiler_name)s_vol%(volnum)s</send>
-    </command>
-
-    <command>
-      <expect>Volume '%(vfiler_name)s_vol%(volnum)s' has been set temporarily offline</expect>
-      <send>vol destroy %(vfiler_name)s_vol%(volnum)s -f</send>
-    </command>
-
-    <condition>cmdoutput.find("Volume '%(vfiler_name)s_vol%(volnum)s' destroyed") >= 0</condition>
-
-  </backout>
-
+<change name="create_secondary_volumes" template='create_netapp_volume' iterator='secondary_volumes'>
+  <target>wibble</target>
+  <depends on='create_primary_volumes'/>
 </change>
 
-
-<!--
-<change name="test_iterator" type="CommandChange" iterator="iter1">
-
-  <prereq>None</prereq>
-
-  <target>wibble</target>
-
-  <preimpl>
-    <command>
-      <send>vol status %(volname)s</send>
-    </command>
-
-    <condition>cmdoutput.find("No volume named '%(volname)s' exists.") >= 0</condition>
-
-  </preimpl>
-
-</change>
--->
-
 </config>

trunk/provisioner.py

@@ -54 +54 @@
         Back out a change that was applied to a specific device.
         """
+
+class UserBailout(Exception):
+    """
+    User denied a change command from executing in Authoritarian mode.
+    This causes the program to bail out complete at exactly that point.
+    """
 
 class Provisioner:
@@ -68 +74 @@
         self.namespace = namespace
         self.authoritarian = authoritarian
+
+        log.debug("My namespace is: %s", self.namespace)
 
     def parse_config_node(self, node):
@@ -148 +156 @@
 
         log.error("Change '%s' failed to apply", change.name)
-        e = failure.check( ChangeConditionFailure )
+        e = failure.check( ChangeConditionFailure, UserBailout )
         if e:
             log.error("  failure was: %s", failure.value )
+            if isinstance(e, UserBailout):
+                log.info("User bailout detected.")
+                return defer.succeed('bailout')
         else:
             tlog.err(failure)
@@ -504 +515 @@
             else:
                 log.info(" Bailing out at your command.")
-                self.waitingForCommand.errback("User requested manual bailout.")
+                raise UserBailout("Bailing out at your command")
+                #self.waitingForCommand.errback("User requested manual bailout.")
                 return
             pass
@@ -572 +584 @@
         for (expr, cmdstring) in expectset:
 
-            # Perform variable substitution on the command string
-            log.debug("determining commandstring from template: %s", cmdstring)
-            cmdstring = str(util.substituteVariables(cmdstring, namespace))
-            log.debug("commandstring is: %s", cmdstring)
-
-            # add the cmdstring to the namespace
-            namespace['command.send'] = cmdstring
-
-            log.debug("Determining command base from template: %s", self.command)
-            command = str(util.substituteVariables(self.command, namespace))
-
+            try:
+                # Perform variable substitution on the command string
+                log.debug("determining commandstring from template: %s", cmdstring)
+                cmdstring = str(util.substituteVariables(cmdstring, namespace))
+                log.debug("commandstring is: %s", cmdstring)
+
+                # add the cmdstring to the namespace
+                namespace['command.send'] = cmdstring
+
+                log.debug("Determining command base from template: %s", self.command)
+                command = str(util.substituteVariables(self.command, namespace))
+            except KeyError, e:
+                log.error("KeyError in commands: %s" % e)
+                self.all_commands_defer.errback( e )
+                return self.all_commands_defer
+            
             #log.debug("checking expr: %s" % expr)
             log.debug("cmdstring is: %s" % command)
@@ -605 +622 @@
         log.debug("spawning command...")
         self.waitingForCommand = defer.Deferred()
+
         # If we're in authoritarian mode, wait for confirmation
         # that we should execute the command.
@@ -617 +635 @@
                 self.exitcode = -1
                 self.cmdoutput = 'User requested manual bailout'
-                self.waitingForCommand.errback( Exception("User requested manual bailout.") )
+                log.critical("User requested manual bailout")
+                self.waitingForCommand.errback( UserBailout("User requested manual bailout.") )
                 return self.waitingForCommand
             pass
@@ -638 +657 @@
         self.cmdoutput += result[1]
         log.debug("current results: exit '%d', output: %s", self.exitcode, self.cmdoutput)
-        log.error("Process: %s", self.p)
         
     def command_failed(self, failure):
         errorstr = "%s: %s" % (self.exitcode, self.cmdoutput)
         log.error("Command failed: %s", errorstr)
-        log.error("Process: %s", self.p)
-        self.exitcode = result[0]
-        self.cmdoutput += result[1]
         #self.all_commands_defer.errback( Exception(errorstr) )
 
@@ -704 +719 @@
                 self.parent.waitingForCommand.callback( (self.exitCode, self.databuf) )
                 pass
+
+        except AlreadyCalled, AlreadyCancelled:
+            pass
                 
         except Exception, e:
@@ -713 +731 @@
 
     def timedOut(self):
+        # FIXME: If the command times out, we need to ignore anything that comes
+        # back from the process, or we'll notify of error conditions more than once
+        # I'm hoping the AlreadyCalled an AlreadyCancelled catch above will take care of this.
         log.error("Timed out waiting for command to exit")
         self.transport.loseConnection()