Changeset 28 for trunk/provisioner.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/provisioner.py (modified) (10 diffs)

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()