etch 4.0.0 → 5.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0dc3526272784c37e6a08e8fcc51b2e58b75a4f
+  data.tar.gz: 2c781954de4ce096bbd90ed8dcb5e7925104a764
+SHA512:
+  metadata.gz: e6f0b89da1febca23dcfcc60831bebbb0166f1a39a37882c6c837d8fbbf6f6962cc20845ff5daa9fdd282948f83326beb25acaeaf23d2a42762495721577f37d
+  data.tar.gz: 2ba80b2378ae28d8da759dc6ba0597d4f0f016983a33e573a5a5d48d344ebbd80ced891616407db889b0fa015ee9f3a52a9ab7747c4f75c115145944e69d2c67

data/Rakefile

@@ -1,17 +1,16 @@
-require 'rake/gempackagetask'
+require 'rubygems/package_task'
 spec = Gem::Specification.new do |s|
-  s.name	= 'etch'
-  s.summary	= 'Etch system configuration management client'
+  s.name        = 'etch'
+  s.summary     = 'Etch system configuration management client'
   s.add_dependency('facter')
-  s.version = '4.0.0'
+  s.version = '5.0.0'
   s.author = 'Jason Heiss'
   s.email = 'etch-users@lists.sourceforge.net'
-  s.homepage = 'http://etch.sourceforge.net'
+  s.homepage = 'http://etch.github.io'
   s.rubyforge_project = 'etchsyscm'
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version = '>=1.8'
-  s.files	= Dir['**/**']
+  s.files       = Dir['**/**']
   s.executables = [ 'etch', 'etch_to_trunk', 'etch_cron_wrapper' ]
 end
-Rake::GemPackageTask.new(spec).define
-
+Gem::PackageTask.new(spec).define

data/lib/etch.rb

@@ -10,6 +10,8 @@ Silently.silently do
   require 'fileutils'   # mkdir_p
   require 'erb'
   require 'logger'
+  require 'yaml'
+  require 'set'
 end
 require 'versiontype' # Version
 
@@ -97,77 +99,66 @@ class Etch
     @sitelibbase       = "#{@configdir}/sitelibs"
     @config_dtd_file   = "#{@configdir}/config.dtd"
     @commands_dtd_file = "#{@configdir}/commands.dtd"
-    @defaults_file     = "#{@configdir}/defaults.xml"
-    @nodes_file        = "#{@configdir}/nodes.xml"
-    @nodegroups_file   = "#{@configdir}/nodegroups.xml"
     
     #
-    # Load the DTD which is used to validate config.xml files
+    # These will be loaded on demand so that all-YAML configurations don't require them
     #
     
-    @config_dtd = Etch.xmlloaddtd(@config_dtd_file)
-    @commands_dtd = Etch.xmlloaddtd(@commands_dtd_file)
+    @config_dtd = nil
+    @commands_dtd = nil
     
     #
-    # Load the defaults.xml file which sets defaults for parameters that the
-    # users don't specify in their config.xml files.
+    # Load the defaults file which sets defaults for parameters that the
+    # users don't specify in their config files.
     #
     
-    @defaults_xml = Etch.xmlload(@defaults_file)
+    @defaults = load_defaults
     
     #
     # Load the nodes file
     #
 
-    @nodes_xml = Etch.xmlload(@nodes_file)
+    groups = Set.new
+    @nodes, nodesfile = load_nodes
     # Extract the groups for this node
-    thisnodeelem = Etch.xmlfindfirst(@nodes_xml, "/nodes/node[@name='#{@fqdn}']")
-    groupshash = {}
-    if thisnodeelem
-      Etch.xmleach(thisnodeelem, 'group') { |group| groupshash[Etch.xmltext(group)] = true }
+    if @nodes[@fqdn]
+      @nodes[@fqdn].each{|group| groups << group}
     else
-      @logger.warn "No entry found for node #{@fqdn} in nodes.xml"
+      @logger.warn "No entry found for node #{@fqdn} in #{nodesfile}"
       # Some folks might want to terminate here
-      #raise "No entry found for node #{@fqdn} in nodes.xml"
+      #raise "No entry found for node #{@fqdn} in #{nodesfile}"
     end
-    @dlogger.debug "Native groups for node #{@fqdn}: #{groupshash.keys.sort.join(',')}"
+    @dlogger.debug "Native groups for node #{@fqdn}: #{groups.sort.join(',')}"
 
     #
     # Load the node groups file
     #
 
-    @nodegroups_xml = Etch.xmlload(@nodegroups_file)
-
-    # Extract the node group hierarchy into a hash for easy reference
-    @group_hierarchy = {}
-    Etch.xmleach(@nodegroups_xml, '/nodegroups/nodegroup') do |parent|
-      Etch.xmleach(parent, 'child') do |child|
-        @group_hierarchy[Etch.xmltext(child)] = [] if !@group_hierarchy[Etch.xmltext(child)]
-        @group_hierarchy[Etch.xmltext(child)] << Etch.xmlattrvalue(parent, 'name')
-      end
-    end
+    @group_hierarchy = load_nodegroups
 
     # Fill out the list of groups for this node with any parent groups
-    parentshash = {}
-    groupshash.keys.each do |group|
-      parents = get_parent_nodegroups(group)
-      parents.each { |parent| parentshash[parent] = true }
+    parents = Set.new
+    groups.each do |group|
+      parents.merge get_parent_nodegroups(group)
     end
-    parentshash.keys.each { |parent| groupshash[parent] = true }
-    @dlogger.debug "Added groups for node #{@fqdn} due to node group hierarchy: #{parentshash.keys.sort.join(',')}"
+    parents.each{|parent| groups << parent}
+    @dlogger.debug "Added groups for node #{@fqdn} due to node group hierarchy: #{parents.sort.join(',')}"
 
+    #
     # Run the external node grouper
-    externalhash = {}
+    #
+
+    externals = Set.new
     IO.popen(File.join(@configdir, 'nodegrouper') + ' ' + @fqdn) do |pipe|
-      pipe.each { |group| externalhash[group.chomp] = true }
+      pipe.each{|group| externals << group.chomp}
     end
     if !$?.success?
-      raise "External node grouper exited with error #{$?.exitstatus}"
+      raise "External node grouper #{File.join(@configdir, 'nodegrouper')} exited with error #{$?.exitstatus}"
     end
-    externalhash.keys.each { |external| groupshash[external] = true }
-    @dlogger.debug "Added groups for node #{@fqdn} due to external node grouper: #{externalhash.keys.sort.join(',')}"
+    groups.merge externals
+    @dlogger.debug "Added groups for node #{@fqdn} due to external node grouper: #{externals.sort.join(',')}"
 
-    @groups = groupshash.keys.sort
+    @groups = groups.sort
     @dlogger.debug "Total groups for node #{@fqdn}: #{@groups.join(',')}"
 
     #
@@ -180,9 +171,11 @@ class Etch
       @dlogger.debug "Building complete file list for request from #{@fqdn}"
       if File.exist?(@sourcebase)
         Find.find(@sourcebase) do |path|
-          if File.directory?(path) && File.exist?(File.join(path, 'config.xml'))
+          if File.directory?(path) &&
+             (File.exist?(File.join(path, 'config.xml')) ||
+              File.exist?(File.join(path, 'config.yml')))
             # Strip @sourcebase from start of path
-            filelist << path.sub(Regexp.new('^' + Regexp.escape(@sourcebase)), '')
+            filelist << path.sub(Regexp.new('\A' + Regexp.escape(@sourcebase)), '')
           end
         end
       end
@@ -200,8 +193,8 @@ class Etch
     @already_generated = {}
     @generation_status = {}
     @configs = {}
-    @need_orig = {}
-    @allcommands = {}
+    @need_orig = []
+    @commands = {}
     @retrycommands = {}
     
     filelist.each do |file|
@@ -218,7 +211,9 @@ class Etch
       @dlogger.debug "Building complete configuration commands for request from #{@fqdn}"
       if File.exist?(@commandsbase)
         Find.find(@commandsbase) do |path|
-          if File.directory?(path) && File.exist?(File.join(path, 'commands.xml'))
+          if File.directory?(path) &&
+             (File.exist?(File.join(path, 'commands.yml')) ||
+              File.exist?(File.join(path, 'commands.xml')))
             commandnames << File.basename(path)
           end
         end
@@ -239,7 +234,7 @@ class Etch
     
     {:configs => @configs,
      :need_orig => @need_orig,
-     :allcommands => @allcommands,
+     :commands => @commands,
      :retrycommands => @retrycommands}
   end
 
@@ -248,17 +243,104 @@ class Etch
   #
   private
 
+  def load_defaults
+    yamldefaults = "#{@configdir}/defaults.yml"
+    xmldefaults = "#{@configdir}/defaults.xml"
+    if File.exist?(yamldefaults)
+      @dlogger.debug "Loading defaults from #{yamldefaults}"
+      defaults = symbolize_etch_keys(YAML.load(File.read(yamldefaults)))
+    elsif File.exist?(xmldefaults)
+      @dlogger.debug "Loading defaults from #{xmldefaults}"
+      defaults = {}
+      defaults_xml = Etch.xmlload(xmldefaults)
+      Etch.xmleach(defaults_xml, '/config/*') do |node|
+        section = node.name.to_sym
+        defaults[section] ||= {}
+        Etch.xmleachall(node) do |entry|
+          value = Etch.xmltext(entry)
+          # Convert things that look like numbers to match how YAML is parsed
+          if value.to_i.to_s == value
+            value = value.to_i
+          end
+          defaults[section][entry.name.to_sym] = value
+        end
+      end
+    else
+      raise "Neither defaults.yml nor defaults.xml exists"
+    end
+    # Ensure the top level sections exist
+    [:file, :link, :directory].each{|top| defaults[top] ||= {}}
+    defaults
+  end
+  def symbolize_etch_key(key)
+    key =~ /\Awhere (.*)/ ? key : key.to_sym
+  end
+  def symbolize_etch_keys(hash)
+    case hash
+    when Hash
+      Hash[hash.collect{|k,v| [symbolize_etch_key(k), symbolize_etch_keys(v)]}]
+    when Array
+      hash.collect{|e| symbolize_etch_keys(e)}
+    else
+      hash
+    end
+  end
+  def load_nodes
+    yamlnodes = "#{@configdir}/nodes.yml"
+    xmlnodes = "#{@configdir}/nodes.xml"
+    if File.exist?(yamlnodes)
+      @dlogger.debug "Loading native groups from #{yamlnodes}"
+      nodesfile = 'nodes.yml'
+      nodes = YAML.load(File.read(yamlnodes))
+      nodes ||= {}
+    elsif File.exist?(xmlnodes)
+      @dlogger.debug "Loading native groups from #{xmlnodes}"
+      nodesfile = 'nodes.xml'
+      nodes_xml = Etch.xmlload(xmlnodes)
+      nodes = {}
+      Etch.xmleach(nodes_xml, '/nodes/node') do |node|
+        name = Etch.xmlattrvalue(node, 'name')
+        nodes[name] ||= []
+        Etch.xmleach(node, 'group') do |group|
+          nodes[name] << Etch.xmltext(group)
+        end
+      end
+    end
+    nodes ||= {}
+    nodesfile ||= '<none>'
+    [nodes, nodesfile]
+  end
+  def load_nodegroups
+    yamlnodegroups = "#{@configdir}/nodegroups.yml"
+    xmlnodegroups = "#{@configdir}/nodegroups.xml"
+    if File.exist?(yamlnodegroups)
+      @dlogger.debug "Loading node group hierarchy from #{yamlnodegroups}"
+      group_hierarchy = YAML.load(File.read(yamlnodegroups))
+    elsif File.exist?(xmlnodegroups)
+      @dlogger.debug "Loading node group hierarchy from #{xmlnodegroups}"
+      group_hierarchy = {}
+      nodegroups_xml = Etch.xmlload(xmlnodegroups)
+      Etch.xmleach(nodegroups_xml, '/nodegroups/nodegroup') do |parent|
+        parentname = Etch.xmlattrvalue(parent, 'name')
+        group_hierarchy[parentname] ||= []
+        Etch.xmleach(parent, 'child') do |child|
+          group_hierarchy[parentname] << Etch.xmltext(child)
+        end
+      end
+    end
+    group_hierarchy || {}
+  end
+
   # Recursive method to get all of the parents of a node group
   def get_parent_nodegroups(group)
-    parentshash = {}
-    if @group_hierarchy[group]
-      @group_hierarchy[group].each do |parent|
-        parentshash[parent] = true
-        grandparents = get_parent_nodegroups(parent)
-        grandparents.each { |gp| parentshash[gp] = true }
+    parents = Set.new
+    @group_hierarchy.each do |parent, children|
+      if children.include?(group)
+        parents << parent
+        parents.merge get_parent_nodegroups(parent)
       end
     end
-    parentshash.keys.sort
+    parents
   end
   
   # Returns the value of the generation_status variable, see comments in
@@ -279,31 +361,7 @@ class Etch
     end
     @filestack[file] = true
     
-    config_xml_file = File.join(@sourcebase, file, 'config.xml')
-    if !File.exist?(config_xml_file)
-      raise "config.xml for #{file} does not exist"
-    end
-    
-    # Load the config.xml file
-    begin
-      config_xml = Etch.xmlload(config_xml_file)
-    rescue Exception => e
-      raise Etch.wrap_exception(e, "Error loading config.xml for #{file}:\n" + e.message)
-    end
-    
-    # Filter the config.xml file by looking for attributes
-    begin
-      configfilter!(Etch.xmlroot(config_xml))
-    rescue Exception => e
-      raise Etch.wrap_exception(e, "Error filtering config.xml for #{file}:\n" + e.message)
-    end
-    
-    # Validate the filtered file against config.dtd
-    begin
-      Etch.xmlvalidate(config_xml, @config_dtd)
-    rescue Exception => e
-      raise Etch.wrap_exception(e, "Filtered config.xml for #{file} fails validation:\n" + e.message)
-    end
+    config = load_config(file)
     
     generation_status = :unknown
     # As we go through the process of generating the file we'll end up with
@@ -313,7 +371,7 @@ class Etch
     #          generally the original file
     # success: we successfully processed a valid configuration
     # unknown: no valid configuration nor errors encountered, probably because
-    #          filtering removed everything from the config.xml file.  This
+    #          filtering removed everything from the config file.  This
     #          should be considered a successful outcome, it indicates the
     #          caller/client provided us with all required data and our result
     #          is that no action needs to be taken.
@@ -322,18 +380,16 @@ class Etch
     # If we encounter either failure or success we set it to false or :success.
     catch :generate_done do
       # Generate any other files that this file depends on
-      depends = []
       proceed = true
-      Etch.xmleach(config_xml, '/config/depend') do |depend|
-        @dlogger.debug "Generating dependency #{Etch.xmltext(depend)}"
-        depends << Etch.xmltext(depend)
-        r = generate_file(Etch.xmltext(depend), request)
+      config[:depend] && config[:depend].each do |depend|
+        @dlogger.debug "Generating dependency #{depend}"
+        r = generate_file(depend, request)
         proceed = proceed && r
       end
       # Also generate any commands that this file depends on
-      Etch.xmleach(config_xml, '/config/dependcommand') do |dependcommand|
-        @dlogger.debug "Generating command dependency #{Etch.xmltext(dependcommand)}"
-        r = generate_commands(Etch.xmltext(dependcommand), request)
+      config[:dependcommand] && config[:dependcommand].each do |dependcommand|
+        @dlogger.debug "Generating command dependency #{dependcommand}"
+        r = generate_commands(dependcommand, request)
         proceed = proceed && r
       end
       
@@ -364,13 +420,13 @@ class Etch
         # bfile and afile.  This repeats forever as the server isn't smart enough
         # to ask for everything it needs and the client isn't smart enough to send
         # everything.
-        depends.each { |depend| @need_orig[depend] = true }
+        config[:depend] && config[:depend].each {|depend| @need_orig << depend}
         
         # Tell the client to request this file again
-        @need_orig[file] = true
+        @need_orig << file
         
         # Strip this file's config down to the bare necessities
-        filter_xml_completely!(config_xml, ['depend', 'setup'])
+        filter_config_completely!(config, [:depend, :setup])
         
         # And hit the eject button
         generation_status = false
@@ -385,23 +441,23 @@ class Etch
 
       # Check to see if the user has requested that we revert back to the
       # original file.
-      if Etch.xmlfindfirst(config_xml, '/config/revert')
+      if config[:revert]
         # Pass the revert action back to the client
-        filter_xml!(config_xml, ['revert'])
+        filter_config!(config, [:revert])
         generation_status = :success
         throw :generate_done
       end
   
       # Perform any server setup commands
-      if Etch.xmlfindfirst(config_xml, '/config/server_setup')
+      if config[:server_setup]
         @dlogger.debug "Processing server setup commands"
-        Etch.xmleach(config_xml, '/config/server_setup/exec') do |cmd|
-          @dlogger.debug "  Executing #{Etch.xmltext(cmd)}"
+        config[:server_setup].each do |cmd|
+          @dlogger.debug "  Executing #{cmd}"
           # Explicitly invoke using /bin/sh so that syntax like
           # "FOO=bar myprogram" works.
-          success = system('/bin/sh', '-c', Etch.xmltext(cmd))
+          success = system('/bin/sh', '-c', cmd)
           if !success
-            raise "Server setup command #{Etch.xmltext(cmd)} for file #{file} exited with non-zero value"
+            raise "Server setup command #{cmd} for file #{file} exited with non-zero value"
           end
         end
       end
@@ -416,42 +472,47 @@ class Etch
       # Regular file
       #
 
-      if Etch.xmlfindfirst(config_xml, '/config/file')
+      if config[:file]
         #
         # Assemble the contents for the file
         #
         newcontents = ''
-      
-        if Etch.xmlfindfirst(config_xml, '/config/file/source/plain')
-          plain_elements = Etch.xmlarray(config_xml, '/config/file/source/plain')
-          if check_for_inconsistency(plain_elements)
-            raise "Inconsistent 'plain' entries for #{file}"
+        if config[:file][:plain] && !config[:file][:plain].empty?
+          if config[:file][:plain].kind_of?(Array)
+            if check_for_inconsistency(config[:file][:plain])
+              raise "Inconsistent 'plain' entries for #{file}"
+            end
+            plain = config[:file][:plain].first
+          else
+            plain = config[:file][:plain]
           end
-        
           # Just slurp the file in
-          plain_file = Etch.xmltext(plain_elements.first)
-          newcontents = IO.read(plain_file)
-        elsif Etch.xmlfindfirst(config_xml, '/config/file/source/template')
-          template_elements = Etch.xmlarray(config_xml, '/config/file/source/template')
-          if check_for_inconsistency(template_elements)
-            raise "Inconsistent 'template' entries for #{file}"
+          newcontents = IO.read(plain)
+        elsif config[:file][:template] && !config[:file][:template].empty?
+          if config[:file][:template].kind_of?(Array)
+            if check_for_inconsistency(config[:file][:template])
+              raise "Inconsistent 'template' entries for #{file}"
+            end
+            template = config[:file][:template].first
+          else
+            template = config[:file][:template]
           end
-        
           # Run the template through ERB to generate the file contents
-          template = Etch.xmltext(template_elements.first)
           external = EtchExternalSource.new(file, original_file, @facts, @groups, local_requests, @sourcebase, @commandsbase, @sitelibbase, @dlogger)
           newcontents = external.process_template(template)
-        elsif Etch.xmlfindfirst(config_xml, '/config/file/source/script')
-          script_elements = Etch.xmlarray(config_xml, '/config/file/source/script')
-          if check_for_inconsistency(script_elements)
-            raise "Inconsistent 'script' entries for #{file}"
+        elsif config[:file][:script] && !config[:file][:script].empty?
+          if config[:file][:script].kind_of?(Array)
+            if check_for_inconsistency(config[:file][:script])
+              raise "Inconsistent 'script' entries for #{file}"
+            end
+            script = config[:file][:script].first
+          else
+            script = config[:file][:script]
           end
-        
           # Run the script to generate the file contents
-          script = Etch.xmltext(script_elements.first)
           external = EtchExternalSource.new(file, original_file, @facts, @groups, local_requests, @sourcebase, @commandsbase, @sitelibbase, @dlogger)
           newcontents = external.run_script(script)
-        elsif Etch.xmlfindfirst(config_xml, '/config/file/always_manage_metadata')
+        elsif config[:file][:always_manage_metadata]
           # always_manage_metadata is a special case where we proceed
           # even if we don't have any source for file contents.
         else
@@ -470,8 +531,8 @@ class Etch
         # keep empty files or always manage the metadata, then assume
         # this file is not applicable to this node and do nothing.
         if newcontents == '' &&
-            ! Etch.xmlfindfirst(config_xml, '/config/file/allow_empty') &&
-            ! Etch.xmlfindfirst(config_xml, '/config/file/always_manage_metadata')
+            ! config[:file][:allow_empty] &&
+            ! config[:file][:always_manage_metadata]
           @dlogger.debug "New contents for file #{file} empty, doing nothing"
         else
           # Finish assembling the file contents as long as we're not
@@ -479,45 +540,33 @@ class Etch
           # proceeding based only on always_manage_metadata we want to make
           # sure that the only action we'll take is to manage metadata, not
           # muck with the file's contents.
-          if !(newcontents == '' &&
-               Etch.xmlfindfirst(config_xml, '/config/file/always_manage_metadata'))
+          if !(newcontents == '' && config[:file][:always_manage_metadata])
             # Add the warning message (if defined)
             warning_file = nil
-            if Etch.xmlfindfirst(config_xml, '/config/file/warning_file')
-              if !Etch.xmltext(Etch.xmlfindfirst(config_xml, '/config/file/warning_file')).empty?
-                warning_file = Etch.xmltext(Etch.xmlfindfirst(config_xml, '/config/file/warning_file'))
-              end
-            elsif Etch.xmlfindfirst(@defaults_xml, '/config/file/warning_file')
-              if !Etch.xmltext(Etch.xmlfindfirst(@defaults_xml, '/config/file/warning_file')).empty?
-                warning_file = Etch.xmltext(Etch.xmlfindfirst(@defaults_xml, '/config/file/warning_file'))
-              end
+            if config[:file][:warning_file] && !config[:file][:warning_file].empty?
+              warning_file = config[:file][:warning_file]
+            # This allows the user to set warning_file to false or an empty string in their
+            # config file to prevent the use of the default warning file
+            elsif !config[:file].include?(:warning_file)
+              warning_file = @defaults[:file][:warning_file]
             end
             if warning_file
+              warnpath = Pathname.new(warning_file)
+              if !File.exist?(warning_file) && !warnpath.absolute?
+                warning_file = File.expand_path(warning_file, @configdir)
+              end
+            end
+            if warning_file && File.exist?(warning_file)
               warning = ''
 
               # First the comment opener
-              comment_open = nil
-              if Etch.xmlfindfirst(config_xml, '/config/file/comment_open')
-                comment_open = Etch.xmltext(Etch.xmlfindfirst(config_xml, '/config/file/comment_open'))
-              elsif Etch.xmlfindfirst(@defaults_xml, '/config/file/comment_open')
-                comment_open = Etch.xmltext(Etch.xmlfindfirst(@defaults_xml, '/config/file/comment_open'))
-              end
+              comment_open = config[:file][:comment_open] || @defaults[:file][:comment_open]
               if comment_open && !comment_open.empty?
                 warning << comment_open << "\n"
               end
 
               # Then the message
-              comment_line = '# '
-              if Etch.xmlfindfirst(config_xml, '/config/file/comment_line')
-                comment_line = Etch.xmltext(Etch.xmlfindfirst(config_xml, '/config/file/comment_line'))
-              elsif Etch.xmlfindfirst(@defaults_xml, '/config/file/comment_line')
-                comment_line = Etch.xmltext(Etch.xmlfindfirst(@defaults_xml, '/config/file/comment_line'))
-              end
-
-              warnpath = Pathname.new(warning_file)
-              if !File.exist?(warning_file) && !warnpath.absolute?
-                warning_file = File.expand_path(warning_file, @configdir)
-              end
+              comment_line = config[:file][:comment_line] || @defaults[:file][:comment_line] || '# '
 
               File.open(warning_file) do |warnfile|
                 while line = warnfile.gets
@@ -526,12 +575,7 @@ class Etch
               end
 
               # And last the comment closer
-              comment_close = nil
-              if Etch.xmlfindfirst(config_xml, '/config/file/comment_close')
-                comment_close = Etch.xmltext(Etch.xmlfindfirst(config_xml, '/config/file/comment_close'))
-              elsif Etch.xmlfindfirst(@defaults_xml, '/config/file/comment_close')
-                comment_close = Etch.xmltext(Etch.xmlfindfirst(@defaults_xml, '/config/file/comment_close'))
-              end
+              comment_close = config[:file][:comment_close] || @defaults[:file][:comment_close]
               if comment_close && !comment_close.empty?
                 warning << comment_close << "\n"
               end
@@ -541,20 +585,20 @@ class Etch
               # scripts) have a special first line.  The user can flag
               # those files to have the warning inserted starting at the
               # second line.
-              if !Etch.xmlfindfirst(config_xml, '/config/file/warning_on_second_line')
+              if !config[:file][:warning_on_second_line]
                 # And then other files (notably Solaris crontabs) can't
                 # have any blank lines.  Normally we insert a blank
                 # line between the warning message and the generated
                 # file to improve readability.  The user can flag us to
                 # not insert that blank line.
-                if !Etch.xmlfindfirst(config_xml, '/config/file/no_space_around_warning')
-                  newcontents = warning + "\n" + newcontents
+                if !config[:file][:no_space_around_warning]
+                  newcontents = warning << "\n" << newcontents
                 else
-                  newcontents = warning + newcontents
+                  newcontents = warning << newcontents
                 end
               else
                 parts = newcontents.split("\n", 2)
-                if !Etch.xmlfindfirst(config_xml, '/config/file/no_space_around_warning')
+                if !config[:file][:no_space_around_warning]
                   newcontents = parts[0] << "\n\n" << warning << "\n" << parts[1]
                 else
                   newcontents = parts[0] << warning << parts[1]
@@ -563,54 +607,50 @@ class Etch
             end # if warning_file
     
             # Add the generated file contents to the XML
-            Etch.xmladd(config_xml, '/config/file', 'contents', Base64.encode64(newcontents))
+            config[:file][:contents] = Base64.encode64(newcontents)
           end
 
-          # Remove the source configuration from the XML, the
+          # Remove the source configuration from the config, the
           # client won't need to see it
-          Etch.xmlremovepath(config_xml, '/config/file/source')
+          config[:file].delete(:plain)
+          config[:file].delete(:template)
+          config[:file].delete(:script)
 
-          # Remove all of the warning related elements from the XML, the
+          # Remove all of the warning related elements from the config, the
           # client won't need to see them
-          Etch.xmlremovepath(config_xml, '/config/file/warning_file')
-          Etch.xmlremovepath(config_xml, '/config/file/warning_on_second_line')
-          Etch.xmlremovepath(config_xml, '/config/file/no_space_around_warning')
-          Etch.xmlremovepath(config_xml, '/config/file/comment_open')
-          Etch.xmlremovepath(config_xml, '/config/file/comment_line')
-          Etch.xmlremovepath(config_xml, '/config/file/comment_close')
+          config[:file].delete(:warning_file)
+          config[:file].delete(:warning_on_second_line)
+          config[:file].delete(:no_space_around_warning)
+          config[:file].delete(:comment_open)
+          config[:file].delete(:comment_line)
+          config[:file].delete(:comment_close)
         
-          # If the XML doesn't contain ownership and permissions entries
+          # If the config doesn't contain ownership and permissions entries
           # then add appropriate ones based on the defaults
-          if !Etch.xmlfindfirst(config_xml, '/config/file/owner')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/file/owner')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/file/owner'),
-                Etch.xmlfindfirst(config_xml, '/config/file'))
+          if !config[:file][:owner]
+            if @defaults[:file][:owner]
+              config[:file][:owner] = @defaults[:file][:owner]
             else
-              raise "defaults.xml needs /config/file/owner"
+              raise "defaults needs file->owner"
             end
           end
-          if !Etch.xmlfindfirst(config_xml, '/config/file/group')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/file/group')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/file/group'),
-                Etch.xmlfindfirst(config_xml, '/config/file'))
+          if !config[:file][:group]
+            if @defaults[:file][:group]
+              config[:file][:group] = @defaults[:file][:group]
             else
-              raise "defaults.xml needs /config/file/group"
+              raise "defaults needs file->group"
             end
           end
-          if !Etch.xmlfindfirst(config_xml, '/config/file/perms')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/file/perms')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/file/perms'),
-                Etch.xmlfindfirst(config_xml, '/config/file'))
+          if !config[:file][:perms]
+            if @defaults[:file][:perms]
+              config[:file][:perms] = @defaults[:file][:perms]
             else
-              raise "defaults.xml needs /config/file/perms"
+              raise "defaults needs file->perms"
             end
           end
       
           # Send the file contents and metadata to the client
-          filter_xml!(config_xml, ['file'])
+          filter_config!(config, [:file])
       
           generation_status = :success
           throw :generate_done
@@ -621,33 +661,34 @@ class Etch
       # Symbolic link
       #
   
-      if Etch.xmlfindfirst(config_xml, '/config/link')
+      if config[:link]
         dest = nil
-    
-        if Etch.xmlfindfirst(config_xml, '/config/link/dest')
-          dest_elements = Etch.xmlarray(config_xml, '/config/link/dest')
-          if check_for_inconsistency(dest_elements)
-            raise "Inconsistent 'dest' entries for #{file}"
+        if config[:link][:dest] && !config[:link][:dest].empty?
+          if config[:link][:dest].kind_of?(Array)
+            if check_for_inconsistency(config[:link][:dest])
+              raise "Inconsistent 'dest' entries for #{file}"
+            end
+            dest = config[:link][:dest].first
+          else
+            dest = config[:link][:dest]
           end
-      
-          dest = Etch.xmltext(dest_elements.first)
-        elsif Etch.xmlfindfirst(config_xml, '/config/link/script')
+        elsif config[:link][:script] && !config[:link][:script].empty?
           # The user can specify a script to perform more complex
           # testing to decide whether to create the link or not and
           # what its destination should be.
-        
-          script_elements = Etch.xmlarray(config_xml, '/config/link/script')
-          if check_for_inconsistency(script_elements)
-            raise "Inconsistent 'script' entries for #{file}"
+          if config[:link][:script].kind_of?(Array)
+            if check_for_inconsistency(config[:link][:script])
+              raise "Inconsistent 'script' entries for #{file}"
+            end
+            script = config[:link][:script].first
+          else
+            script = config[:link][:script]
           end
-        
-          script = Etch.xmltext(script_elements.first)
           external = EtchExternalSource.new(file, original_file, @facts, @groups, local_requests, @sourcebase, @commandsbase, @sitelibbase, @dlogger)
           dest = external.run_script(script)
-        
-          # Remove the script element(s) from the XML, the client won't need
-          # to see them
-          script_elements.each { |se| Etch.xmlremove(config_xml, se) }
+          # Remove the script entry from the config, the client won't need
+          # to see it
+          config[:link].delete(:script)
         else
           # If the filtering has removed the destination for the link,
           # that means it doesn't apply to this node.
@@ -657,44 +698,34 @@ class Etch
         if !dest || dest.empty?
           @dlogger.debug "Destination for link #{file} empty, doing nothing"
         else
-          # If there isn't a dest element in the XML (if the user used a
-          # script) then insert one for the benefit of the client
-          if !Etch.xmlfindfirst(config_xml, '/config/link/dest')
-            Etch.xmladd(config_xml, '/config/link', 'dest', dest)
-          end
+          config[:link][:dest] = dest
 
-          # If the XML doesn't contain ownership and permissions entries
+          # If the config doesn't contain ownership and permissions entries
           # then add appropriate ones based on the defaults
-          if !Etch.xmlfindfirst(config_xml, '/config/link/owner')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/link/owner')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/link/owner'),
-                Etch.xmlfindfirst(config_xml, '/config/link'))
+          if !config[:link][:owner]
+            if @defaults[:link][:owner]
+              config[:link][:owner] = @defaults[:link][:owner]
             else
-              raise "defaults.xml needs /config/link/owner"
+              raise "defaults needs link->owner"
             end
           end
-          if !Etch.xmlfindfirst(config_xml, '/config/link/group')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/link/group')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/link/group'),
-                Etch.xmlfindfirst(config_xml, '/config/link'))
+          if !config[:link][:group]
+            if @defaults[:link][:group]
+              config[:link][:group] = @defaults[:link][:group]
             else
-              raise "defaults.xml needs /config/link/group"
+              raise "defaults needs link->group"
             end
           end
-          if !Etch.xmlfindfirst(config_xml, '/config/link/perms')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/link/perms')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/link/perms'),
-                Etch.xmlfindfirst(config_xml, '/config/link'))
+          if !config[:link][:perms]
+            if @defaults[:link][:perms]
+              config[:link][:perms] = @defaults[:link][:perms]
             else
-              raise "defaults.xml needs /config/link/perms"
+              raise "defaults needs link->perms"
             end
           end
       
           # Send the file contents and metadata to the client
-          filter_xml!(config_xml, ['link'])
+          filter_config!(config, [:link])
 
           generation_status = :success
           throw :generate_done
@@ -705,26 +736,35 @@ class Etch
       # Directory
       #
   
-      if Etch.xmlfindfirst(config_xml, '/config/directory')
+      if config[:directory]
         create = false
-        if Etch.xmlfindfirst(config_xml, '/config/directory/create')
-          create = true
-        elsif Etch.xmlfindfirst(config_xml, '/config/directory/script')
+        if config[:directory][:create] &&
+           (!config[:directory][:create].kind_of?(Array) || !config[:directory][:create].empty?)
+          if config[:directory][:create].kind_of?(Array)
+            if check_for_inconsistency(config[:directory][:create])
+              raise "Inconsistent 'create' entries for #{file}"
+            end
+            create = config[:directory][:create].first
+          else
+            create = config[:directory][:create]
+          end
+        elsif config[:directory][:script] && !config[:directory][:script].empty?
           # The user can specify a script to perform more complex testing
           # to decide whether to create the directory or not.
-          script_elements = Etch.xmlarray(config_xml, '/config/directory/script')
-          if check_for_inconsistency(script_elements)
-            raise "Inconsistent 'script' entries for #{file}"
+          if config[:directory][:script].kind_of?(Array)
+            if check_for_inconsistency(config[:directory][:script])
+              raise "Inconsistent 'script' entries for #{file}"
+            end
+            script = config[:directory][:script].first
+          else
+            script = config[:directory][:script]
           end
-        
-          script = Etch.xmltext(script_elements.first)
           external = EtchExternalSource.new(file, original_file, @facts, @groups, local_requests, @sourcebase, @commandsbase, @sitelibbase, @dlogger)
           create = external.run_script(script)
           create = false if create.empty?
-        
-          # Remove the script element(s) from the XML, the client won't need
-          # to see them
-          script_elements.each { |se| Etch.xmlremove(config_xml, se) }
+          # Remove the script entry from the config, the client won't need
+          # to see it
+          config[:directory].delete(:script)
         else
           # If the filtering has removed the directive to create this
           # directory, that means it doesn't apply to this node.
@@ -734,44 +774,34 @@ class Etch
         if !create
           @dlogger.debug "Directive to create directory #{file} false, doing nothing"
         else
-          # If there isn't a create element in the XML (if the user used a
-          # script) then insert one for the benefit of the client
-          if !Etch.xmlfindfirst(config_xml, '/config/directory/create')
-            Etch.xmladd(config_xml, '/config/directory', 'create', nil)
-          end
+          config[:directory][:create] = create
 
-          # If the XML doesn't contain ownership and permissions entries
+          # If the config doesn't contain ownership and permissions entries
           # then add appropriate ones based on the defaults
-          if !Etch.xmlfindfirst(config_xml, '/config/directory/owner')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/directory/owner')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/directory/owner'),
-                Etch.xmlfindfirst(config_xml, '/config/directory'))
+          if !config[:directory][:owner]
+            if @defaults[:directory][:owner]
+              config[:directory][:owner] = @defaults[:directory][:owner]
             else
-              raise "defaults.xml needs /config/directory/owner"
+              raise "defaults.xml needs directory->owner"
             end
           end
-          if !Etch.xmlfindfirst(config_xml, '/config/directory/group')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/directory/group')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/directory/group'),
-                Etch.xmlfindfirst(config_xml, '/config/directory'))
+          if !config[:directory][:group]
+            if @defaults[:directory][:group]
+              config[:directory][:group] = @defaults[:directory][:group]
             else
-              raise "defaults.xml needs /config/directory/group"
+              raise "defaults.xml needs directory->group"
             end
           end
-          if !Etch.xmlfindfirst(config_xml, '/config/directory/perms')
-            if Etch.xmlfindfirst(@defaults_xml, '/config/directory/perms')
-              Etch.xmlcopyelem(
-                Etch.xmlfindfirst(@defaults_xml, '/config/directory/perms'),
-                Etch.xmlfindfirst(config_xml, '/config/directory'))
+          if !config[:directory][:perms]
+            if @defaults[:directory][:perms]
+              config[:directory][:perms] = @defaults[:directory][:perms]
             else
-              raise "defaults.xml needs /config/directory/perms"
+              raise "defaults.xml needs directory->perms"
             end
           end
       
           # Send the file contents and metadata to the client
-          filter_xml!(config_xml, ['directory'])
+          filter_config!(config, [:directory])
       
           generation_status = :success
           throw :generate_done
@@ -782,26 +812,35 @@ class Etch
       # Delete whatever is there
       #
 
-      if Etch.xmlfindfirst(config_xml, '/config/delete')
+      if config[:delete]
         proceed = false
-        if Etch.xmlfindfirst(config_xml, '/config/delete/proceed')
-          proceed = true
-        elsif Etch.xmlfindfirst(config_xml, '/config/delete/script')
+        if config[:delete][:proceed] &&
+           (!config[:delete][:proceed].kind_of?(Array) || !config[:delete][:proceed].empty?)
+          if config[:delete][:proceed].kind_of?(Array)
+            if check_for_inconsistency(config[:delete][:proceed])
+              raise "Inconsistent 'proceed' entries for #{file}"
+            end
+            proceed = config[:delete][:proceed].first
+          else
+            proceed = config[:delete][:proceed]
+          end
+        elsif config[:delete][:script] && !config[:delete][:script].empty?
           # The user can specify a script to perform more complex testing
           # to decide whether to delete the file or not.
-          script_elements = Etch.xmlarray(config_xml, '/config/delete/script')
-          if check_for_inconsistency(script_elements)
-            raise "Inconsistent 'script' entries for #{file}"
+          if config[:delete][:script].kind_of?(Array)
+            if check_for_inconsistency(config[:delete][:script])
+              raise "Inconsistent 'script' entries for #{file}"
+            end
+            script = config[:delete][:script].first
+          else
+            script = config[:delete][:script]
           end
-        
-          script = Etch.xmltext(script_elements.first)
           external = EtchExternalSource.new(file, original_file, @facts, @groups, local_requests, @sourcebase, @commandsbase, @sitelibbase, @dlogger)
           proceed = external.run_script(script)
           proceed = false if proceed.empty?
-        
-          # Remove the script element(s) from the XML, the client won't need
-          # to see them
-          script_elements.each { |se| Etch.xmlremove(config_xml, se) }
+          # Remove the script entry from the config, the client won't need
+          # to see it
+          config[:delete].delete(:script)
         else
           # If the filtering has removed the directive to remove this
           # file, that means it doesn't apply to this node.
@@ -811,14 +850,10 @@ class Etch
         if !proceed
           @dlogger.debug "Directive to delete #{file} false, doing nothing"
         else
-          # If there isn't a proceed element in the XML (if the user used a
-          # script) then insert one for the benefit of the client
-          if !Etch.xmlfindfirst(config_xml, '/config/delete/proceed')
-            Etch.xmladd(config_xml, '/config/delete', 'proceed', nil)
-          end
+          config[:delete][:proceed] = true
 
           # Send the file contents and metadata to the client
-          filter_xml!(config_xml, ['delete'])
+          filter_config!(config, [:delete])
       
           generation_status = :success
           throw :generate_done
@@ -833,12 +868,8 @@ class Etch
     # In addition to successful configs return configs for files that need
     # orig data (generation_status==false) because any setup commands might be
     # needed to create the original file.
-    if generation_status != :unknown &&
-       Etch.xmlfindfirst(config_xml, '/config/*')
-      # The client needs this attribute to know to which file
-      # this chunk of XML refers
-      Etch.xmlattradd(Etch.xmlroot(config_xml), 'filename', file)
-      @configs[file] = config_xml
+    if generation_status != :unknown && !config.empty?
+      @configs[file] = config
     end
   
     @already_generated[file] = true
@@ -848,6 +879,45 @@ class Etch
     generation_status
   end
   
+  def load_config(file)
+    yamlconfig = "#{@sourcebase}/#{file}/config.yml"
+    xmlconfig = "#{@sourcebase}/#{file}/config.xml"
+    if File.exist?(yamlconfig)
+      config = symbolize_etch_keys(YAML.load(File.read(yamlconfig)))
+      config ||= {}
+      begin
+        yamlfilter!(config)
+      rescue Exception => e
+        raise Etch.wrap_exception(e, "Error filtering config.yml for #{file}:\n" + e.message)
+      end
+    elsif File.exist?(xmlconfig)
+      # Load the config.xml file
+      config_xml = nil
+      begin
+        config_xml = Etch.xmlload(xmlconfig)
+      rescue Exception => e
+        raise Etch.wrap_exception(e, "Error loading config.xml for #{file}:\n" + e.message)
+      end
+      # Filter the config.xml file by looking for attributes
+      begin
+        xmlfilter!(Etch.xmlroot(config_xml))
+      rescue Exception => e
+        raise Etch.wrap_exception(e, "Error filtering config.xml for #{file}:\n" + e.message)
+      end
+      # Validate the filtered file against config.dtd
+      @config_dtd ||= Etch.xmlloaddtd(@config_dtd_file)
+      begin
+        Etch.xmlvalidate(config_xml, @config_dtd)
+      rescue Exception => e
+        raise Etch.wrap_exception(e, "Filtered config.xml for #{file} fails validation:\n" + e.message)
+      end
+      config = Etch.config_xml_to_hash(config_xml)
+    else
+      raise "config.yml or config.xml for #{file} does not exist"
+    end
+    config
+  end
+
   # Returns the value of the generation_status variable, see comments in
   # method for possible values.
   def generate_commands(command, request)
@@ -855,7 +925,8 @@ class Etch
     # statements.
     if @already_generated[command]
       @dlogger.debug "Skipping already generated command #{command}"
-      return
+      # Return the status of that previous generation
+      return @generation_status[command]
     end
     
     # Check for circular dependencies, otherwise we're vulnerable
@@ -865,27 +936,7 @@ class Etch
     end
     @filestack[command] = true
     
-    commands_xml_file = File.join(@commandsbase, command, 'commands.xml')
-    if !File.exist?(commands_xml_file)
-      raise "commands.xml for #{command} does not exist"
-    end
-    
-    # Load the commands.xml file
-    commands_xml = Etch.xmlload(commands_xml_file)
-    
-    # Filter the commands.xml file by looking for attributes
-    begin
-      configfilter!(Etch.xmlroot(commands_xml))
-    rescue Exception => e
-      raise Etch.wrap_exception(e, "Error filtering commands.xml for #{command}:\n" + e.message)
-    end
-    
-    # Validate the filtered file against commands.dtd
-    begin
-      Etch.xmlvalidate(commands_xml, @commands_dtd)
-    rescue Exception => e
-      raise Etch.wrap_exception(e, "Filtered commands.xml for #{command} fails validation:\n" + e.message)
-    end
+    cmd = load_command(command)
     
     generation_status = :unknown
     # As we go through the process of generating the command we'll end up with
@@ -895,7 +946,7 @@ class Etch
     #          generally the original file for a file this command depends on
     # success: we successfully processed a valid configuration
     # unknown: no valid configuration nor errors encountered, probably because
-    #          filtering removed everything from the commands.xml file.  This
+    #          filtering removed everything from the commands file.  This
     #          should be considered a successful outcome, it indicates the
     #          caller/client provided us with all required data and our result
     #          is that no action needs to be taken.
@@ -906,17 +957,15 @@ class Etch
       # Generate any other commands that this command depends on
       dependfiles = []
       proceed = true
-      Etch.xmleach(commands_xml, '/commands/depend') do |depend|
-        @dlogger.debug "Generating command dependency #{Etch.xmltext(depend)}"
-        r = generate_commands(Etch.xmltext(depend), request)
-        proceed = proceed && r
+      cmd[:depend] && cmd[:depend].each do |depend|
+        @dlogger.debug "Generating command dependency #{depend}"
+        proceed &= generate_commands(depend, request)
       end
       # Also generate any files that this command depends on
-      Etch.xmleach(commands_xml, '/commands/dependfile') do |dependfile|
-        @dlogger.debug "Generating file dependency #{Etch.xmltext(dependfile)}"
-        dependfiles << Etch.xmltext(dependfile)
-        r = generate_file(Etch.xmltext(dependfile), request)
-        proceed = proceed && r
+      cmd[:dependfile] && cmd[:dependfile].each do |dependfile|
+        @dlogger.debug "Generating file dependency #{dependfile}"
+        dependfiles << dependfile
+        proceed &= generate_file(dependfile, request)
       end
       if !proceed
         @dlogger.debug "One or more dependencies of #{command} need data from client"
@@ -924,63 +973,47 @@ class Etch
         # contents from the client) then we need to tell the client to request
         # all of the files in the dependency tree again.  See the big comment
         # in generate_file for further explanation.
-        dependfiles.each { |dependfile| @need_orig[dependfile] = true }
+        dependfiles.each { |dependfile| @need_orig << dependfile }
         # Try again next time
         @retrycommands[command] = true
         generation_status = false
         throw :generate_done
       end
       
-      # Change into the corresponding directory so that the user can
-      # refer to source files and scripts by their relative pathnames.
-      Dir.chdir "#{@commandsbase}/#{command}"
-      
-      # Check that the resulting document is consistent after filtering
-      remove = []
-      Etch.xmleach(commands_xml, '/commands/step') do |step|
-        guard_exec_elements = Etch.xmlarray(step, 'guard/exec')
-        if check_for_inconsistency(guard_exec_elements)
-          raise "Inconsistent guard 'exec' entries for #{command}: " +
-            guard_exec_elements.collect {|elem| Etch.xmltext(elem)}.join(',')
-        end
-        command_exec_elements = Etch.xmlarray(step, 'command/exec')
-        if check_for_inconsistency(command_exec_elements)
-          raise "Inconsistent command 'exec' entries for #{command}: " +
-            command_exec_elements.collect {|elem| Etch.xmltext(elem)}.join(',')
-        end
-        # If filtering has removed both the guard and command elements
-        # we can remove this step.
-        if guard_exec_elements.empty? && command_exec_elements.empty?
-          remove << step
-        # If filtering has removed the guard but not the command or vice
-        # versa that's an error.
-        elsif guard_exec_elements.empty?
-          raise "Filtering removed guard, but left command: " +
-            Etch.xmltext(command_exec_elements.first)
-        elsif command_exec_elements.empty?
-          raise "Filtering removed command, but left guard: " +
-            Etch.xmltext(guard_exec_elements.first)
+      if cmd[:steps]
+        remove = []
+        cmd[:steps].each do |outerstep|
+          if step = outerstep[:step]
+            if step[:guard] && !step[:guard].kind_of?(Array)
+              step[:guard] = [step[:guard]]
+            end
+            if step[:command] && !step[:command].kind_of?(Array)
+              step[:command] = [step[:command]]
+            end
+            # If filtering has removed both the guard and command elements
+            # then we can remove this step.
+            if (!step[:guard] || step[:guard].empty?) &&
+               (!step[:command] || step[:command].empty?)
+              remove << outerstep
+            # If filtering has removed the guard but not the command or vice
+            # versa that's an error.
+            elsif !step[:guard] || step[:guard].empty?
+              raise "Filtering removed guard, but left command: #{step[:command].join(';')}"
+            elsif !step[:command] || step[:command].empty?
+              raise "Filtering removed command, but left guard: #{step[:guard].join(';')}"
+            else
+              generation_status = :success
+            end
+          end
         end
+        remove.each{|outerstep| cmd[:steps].delete(outerstep)}
       end
-      remove.each { |elem| Etch.xmlremove(commands_xml, elem) }
-      
-      # I'm not sure if we'd benefit from further checking the XML for
-      # validity.  For now we declare success if we got this far.
-      generation_status = :success
     end
     
-    # Earlier we chdir'd into the command's directory in the repository.  It
-    # seems best not to leave this process with that as the cwd.
-    Dir.chdir('/')
-    
     # If filtering didn't remove all the content then add this to the list of
     # commands to be returned to the client.
-    if generation_status && generation_status != :unknown &&
-       Etch.xmlfindfirst(commands_xml, '/commands/*')
-      # Include the commands directory name to aid troubleshooting on the
-      # client side.
-      Etch.xmlattradd(Etch.xmlroot(commands_xml), 'commandname', command)
-      @allcommands[command] = commands_xml
+    if generation_status && generation_status != :unknown && !cmd.empty?
+      @commands[command] = cmd
     end
     
     @already_generated[command] = true
@@ -990,22 +1023,152 @@ class Etch
     generation_status
   end
   
-  ALWAYS_KEEP = ['depend', 'setup', 'pre', 'test_before_post', 'post', 'test']
-  def filter_xml_completely!(config_xml, keepers=[])
-    remove = []
-    Etch.xmleachall(config_xml) do |elem|
-      if !keepers.include?(elem.name)
-        remove << elem
+  def load_command(command)
+    yamlcommand = "#{@commandsbase}/#{command}/commands.yml"
+    xmlcommand = "#{@commandsbase}/#{command}/commands.xml"
+    if File.exist?(yamlcommand)
+      cmd = symbolize_etch_keys(YAML.load(File.read(yamlcommand)))
+      cmd ||= {}
+      begin
+        yamlfilter!(cmd)
+      rescue Exception => e
+        raise Etch.wrap_exception(e, "Error filtering commands.yml for #{command}:\n" + e.message)
       end
+    elsif File.exist?(xmlcommand)
+      # Load the commands.xml file
+      begin
+        command_xml = Etch.xmlload(xmlcommand)
+      rescue Exception => e
+        raise Etch.wrap_exception(e, "Error loading commands.xml for #{command}:\n" + e.message)
+      end
+      # Filter the commands.xml file by looking for attributes
+      begin
+        xmlfilter!(Etch.xmlroot(command_xml))
+      rescue Exception => e
+        raise Etch.wrap_exception(e, "Error filtering commands.xml for #{command}:\n" + e.message)
+      end
+      # Validate the filtered file against commands.dtd
+      @commands_dtd ||= Etch.xmlloaddtd(@commands_dtd_file)
+      begin
+        Etch.xmlvalidate(command_xml, @commands_dtd)
+      rescue Exception => e
+        raise Etch.wrap_exception(e, "Filtered commands.xml for #{command} fails validation:\n" + e.message)
+      end
+      # Convert the filtered XML to a hash
+      cmd = Etch.command_xml_to_hash(command_xml)
+    else
+      raise "commands.yml or commands.xml for #{command} does not exist"
     end
-    remove.each { |elem| Etch.xmlremove(config_xml, elem) }
-    # FIXME: strip comments
+    cmd
+  end
+
+  ALWAYS_KEEP = [:depend, :setup, :pre, :test_before_post, :post, :post_once, :post_once_per_run, :test]
+  def filter_config_completely!(config, keepers=[])
+    config.reject!{|k,v| !keepers.include?(k)}
   end
-  def filter_xml!(config_xml, keepers=[])
-    filter_xml_completely!(config_xml, keepers.concat(ALWAYS_KEEP))
+  def filter_config!(config, keepers=[])
+    filter_config_completely!(config, keepers.concat(ALWAYS_KEEP))
   end
 
-  def configfilter!(element)
+  def yamlfilter!(yaml)
+    result = false
+    case yaml
+    when Hash
+      remove = []
+      yaml.each do |k,v|
+        if v.kind_of?(Hash) &&
+           v.length == 1 &&
+           v.keys.first =~ /\Awhere (.*)/
+          if eval_yaml_condition($1)
+            yaml[k] = v.values.first
+          else
+            remove << k
+          end
+        end
+        yamlfilter!(v)
+      end
+      remove.each{|k| yaml.delete(k)}
+    when Array
+      keep = []
+      yaml.each do |e|
+        if e.kind_of?(Hash) &&
+           e.length == 1 &&
+           e.keys.first =~ /\Awhere (.*)/
+          if eval_yaml_condition($1)
+            keep << e.values.first
+          end
+        else
+          keep << e
+        end
+        yamlfilter!(e)
+      end
+      yaml.replace(keep)
+    end
+  end
+  # Examples:
+  # operatingsystem==Solaris
+  # operatingsystem=~RedHat|CentOS and group==bar
+  # operatingsystem=~RedHat|CentOS or kernel == SunOS and group==bar
+  def eval_yaml_condition(condition)
+    exprs = condition.split(/\s+(and|or)\s+/)
+    prevcond = nil
+    result = nil
+    exprs.each do |expr|
+      case expr
+      when 'and'
+        prevcond = :and
+      when 'or'
+        prevcond = :or
+      else
+        value = nil
+        case
+        when expr =~ /(.+?)\s*=~\s*(.+)/
+          comps = comparables($1)
+          regexp = Regexp.new($2)
+          value = comps.any?{|c| c =~ regexp}
+        when expr =~ /(.+?)\s*!~\s*(.+)/
+          comps = comparables($1)
+          regexp = Regexp.new($2)
+          value = comps.any?{|c| c !~ regexp}
+        when expr =~ /(.+?)\s*(<|<=|>=|>)\s*(.+)/
+          comps = comparables($1)
+          operator = $2.to_sym
+          valueversion = Version.new($3)
+          value = comps.any?{|c| Version.new(c).send(operator, valueversion)}
+        when expr =~ /(.+?)\s*==\s*(.+)/
+          comps = comparables($1)
+          value = comps.include?($2)
+        when expr =~ /(.+?)\s*!=\s*(.+)/
+          comps = comparables($1)
+          value = !comps.include?($2)
+        when expr =~ /(.+?)\s+in\s+(.+)/
+          comps = comparables($1)
+          list = $2.split(/\s*,\s*/)
+          value = list.any?{|item| comps.include?(item)}
+        when expr =~ /(.+?)\s+!in\s+(.+)/
+          comps = comparables($1)
+          list = $2.split(/\s*,\s*/)
+          value = list.none?{|item| comps.include?(item)}
+        else
+          raise "Unable to parse '#{condition}'"
+        end
+        case prevcond
+        when :and
+          result = result && value
+          # False ands short circuit
+          if !result
+            return result
+          end
+        when :or
+          result = result || value
+        else
+          result = value
+        end
+      end
+    end
+    result
+  end
+  def xmlfilter!(element)
     elem_remove = []
     Etch.xmleachall(element) do |elem|
       catch :next_element do
@@ -1020,12 +1183,19 @@ class Etch
         end
         attr_remove.each { |attribute| Etch.xmlattrremove(element, attribute) }
         # Then check any children of this element
-        configfilter!(elem)
+        xmlfilter!(elem)
       end
     end
     elem_remove.each { |elem| Etch.xmlremove(element, elem) }
   end
 
+  def comparables(name)
+    if name == 'group'
+      @groups
+    elsif @facts[name]
+      [@facts[name]]
+    end
+  end
   # Used when parsing each config.xml to filter out any elements which
   # don't match the configuration of this node.  If the attribute matches
   # then we just remove the attribute but leave the element it is attached
@@ -1039,13 +1209,6 @@ class Etch
   # Not yet:
   # - Flow control (if/else)
   def check_attribute(name, value)
-    comparables = []
-    if name == 'group'
-      comparables = @groups
-    elsif @facts[name]
-      comparables = [@facts[name]]
-    end
-    
     result = false
     negate = false
     
@@ -1056,7 +1219,7 @@ class Etch
       value.sub!(/^\!/, '')  # Strip off the bang
     end
     
-    comparables.each do |comp|
+    comparables(name).each do |comp|
       # Numerical comparisons
       # i.e. <plain os="SunOS" osversion=">=5.8"></plain>
       # Note that the standard for XML requires that the < character be
@@ -1092,6 +1255,354 @@ class Etch
     end
   end
   
+  def self.config_xml_to_hash(config_xml)
+    config = {}
+
+    if Etch.xmlfindfirst(config_xml, '/config/revert')
+      config[:revert] = true
+    end
+
+    Etch.xmleach(config_xml, '/config/depend') do |depend|
+      config[:depend] ||= []
+      config[:depend] << Etch.xmltext(depend)
+    end
+    Etch.xmleach(config_xml, '/config/dependcommand') do |dependcommand|
+      config[:dependcommand] ||= []
+      config[:dependcommand] << Etch.xmltext(dependcommand)
+    end
+
+    Etch.xmleach(config_xml, '/config/server_setup/exec') do |cmd|
+      config[:server_setup] ||= []
+      config[:server_setup] << Etch.xmltext(cmd)
+    end
+    Etch.xmleach(config_xml, '/config/setup/exec') do |cmd|
+      config[:setup] ||= []
+      config[:setup] << Etch.xmltext(cmd)
+    end
+    Etch.xmleach(config_xml, '/config/pre/exec') do |cmd|
+      config[:pre] ||= []
+      config[:pre] << Etch.xmltext(cmd)
+    end
+
+    if Etch.xmlfindfirst(config_xml, '/config/file')
+      config[:file] = {}
+    end
+    [:owner, :group, :perms, :warning_file, :comment_open,
+     :comment_line, :comment_close].each do |meta|
+      if metaelem = Etch.xmlfindfirst(config_xml, "/config/file/#{meta}")
+        config[:file][meta] = Etch.xmltext(metaelem)
+      end
+    end
+    [:always_manage_metadata, :warning_on_second_line,
+     :no_space_around_warning, :allow_empty,
+     :overwrite_directory].each do |bool|
+      if Etch.xmlfindfirst(config_xml, "/config/file/#{bool}")
+        config[:file][bool] = true
+      end
+    end
+    [:plain, :template, :script].each do |sourcetype|
+      Etch.xmleach(config_xml, "/config/file/source/#{sourcetype}") do |sourceelem|
+        config[:file][sourcetype] ||= []
+        config[:file][sourcetype] << Etch.xmltext(sourceelem)
+      end
+    end
+
+    if Etch.xmlfindfirst(config_xml, '/config/link')
+      config[:link] = {}
+    end
+    [:owner, :group, :perms].each do |meta|
+      if metaelem = Etch.xmlfindfirst(config_xml, "/config/link/#{meta}")
+        config[:link][meta] = Etch.xmltext(metaelem)
+      end
+    end
+    [:allow_nonexistent_dest, :overwrite_directory].each do |bool|
+      if Etch.xmlfindfirst(config_xml, "/config/link/#{bool}")
+        config[:link][bool] = true
+      end
+    end
+    [:dest, :script].each do |sourcetype|
+      Etch.xmleach(config_xml, "/config/link/#{sourcetype}") do |sourceelem|
+        config[:link][sourcetype] ||= []
+        config[:link][sourcetype] << Etch.xmltext(sourceelem)
+      end
+    end
+
+    if Etch.xmlfindfirst(config_xml, '/config/directory')
+      config[:directory] = {}
+    end
+    [:owner, :group, :perms].each do |meta|
+      if metaelem = Etch.xmlfindfirst(config_xml, "/config/directory/#{meta}")
+        config[:directory][meta] = Etch.xmltext(metaelem)
+      end
+    end
+    [:create].each do |bool|
+      if Etch.xmlfindfirst(config_xml, "/config/directory/#{bool}")
+        config[:directory][bool] = true
+      end
+    end
+    [:script].each do |sourcetype|
+      Etch.xmleach(config_xml, "/config/directory/#{sourcetype}") do |sourceelem|
+        config[:directory][sourcetype] ||= []
+        config[:directory][sourcetype] << Etch.xmltext(sourceelem)
+      end
+    end
+
+    if Etch.xmlfindfirst(config_xml, '/config/delete')
+      config[:delete] = {}
+    end
+    [:overwrite_directory, :proceed].each do |bool|
+      if Etch.xmlfindfirst(config_xml, "/config/delete/#{bool}")
+        config[:delete][bool] = true
+      end
+    end
+    [:script].each do |sourcetype|
+      Etch.xmleach(config_xml, "/config/delete/#{sourcetype}") do |sourceelem|
+        config[:delete][sourcetype] ||= []
+        config[:delete][sourcetype] << Etch.xmltext(sourceelem)
+      end
+    end
+
+    Etch.xmleach(config_xml, '/config/test_before_post/exec') do |cmd|
+      config[:test_before_post] ||= []
+      config[:test_before_post] << Etch.xmltext(cmd)
+    end
+    Etch.xmleach(config_xml, '/config/post/exec') do |cmd|
+      config[:post] ||= []
+      config[:post] << Etch.xmltext(cmd)
+    end
+    Etch.xmleach(config_xml, '/config/post/exec_once') do |cmd|
+      config[:post_once] ||= []
+      config[:post_once] << Etch.xmltext(cmd)
+    end
+    Etch.xmleach(config_xml, '/config/post/exec_once_per_run') do |cmd|
+      config[:post_once_per_run] ||= []
+      config[:post_once_per_run] << Etch.xmltext(cmd)
+    end
+    Etch.xmleach(config_xml, '/config/test/exec') do |cmd|
+      config[:test] ||= []
+      config[:test] << Etch.xmltext(cmd)
+    end
+
+    config
+  end
+  def self.config_hash_to_xml(config, file)
+    doc = Etch.xmlnewdoc
+    root = Etch.xmlnewelem('config', doc)
+    Etch.xmlattradd(root, 'filename', file)
+    Etch.xmlsetroot(doc, root)
+    if config[:revert]
+      root << Etch.xmlnewelem('revert', doc)
+    end
+    if config[:depend]
+      config[:depend].each do |depend|
+        depelem = Etch.xmlnewelem('depend', doc)
+        Etch.xmlsettext(depelem, depend)
+        root << depelem
+      end
+    end
+    if config[:dependcommand]
+      config[:dependcommand].each do |dependcommand|
+        depelem = Etch.xmlnewelem('dependcommand', doc)
+        Etch.xmlsettext(depelem, dependcommand)
+        root << depelem
+      end
+    end
+    if config[:setup]
+      elem = Etch.xmlnewelem('setup', doc)
+      config[:setup].each do |exec|
+        execelem = Etch.xmlnewelem('exec', doc)
+        Etch.xmlsettext(execelem, exec)
+        elem << execelem
+      end
+      root << elem
+    end
+    if config[:pre]
+      elem = Etch.xmlnewelem('pre', doc)
+      config[:pre].each do |exec|
+        execelem = Etch.xmlnewelem('exec', doc)
+        Etch.xmlsettext(execelem, exec)
+        elem << execelem
+      end
+      root << elem
+    end
+    if config[:file]
+      fileelem = Etch.xmlnewelem('file', doc)
+      root << fileelem
+      [:owner, :group, :perms].each do |text|
+        if config[:file][text]
+          textelem = Etch.xmlnewelem(text.to_s, doc)
+          Etch.xmlsettext(textelem, config[:file][text])
+          fileelem << textelem
+        end
+      end
+      [:overwrite_directory].each do |bool|
+        if config[:file][bool]
+          boolelem = Etch.xmlnewelem(bool.to_s, doc)
+          fileelem << boolelem
+        end
+      end
+      if config[:file][:contents]
+        elem = Etch.xmlnewelem('contents', doc)
+        Etch.xmlsettext(elem, config[:file][:contents])
+        fileelem << elem
+      end
+    end
+    if config[:link]
+      linkelem = Etch.xmlnewelem('link', doc)
+      root << linkelem
+      [:owner, :group, :perms].each do |text|
+        if config[:link][text]
+          textelem = Etch.xmlnewelem(text.to_s, doc)
+          Etch.xmlsettext(textelem, config[:link][text])
+          linkelem << textelem
+        end
+      end
+      [:allow_nonexistent_dest, :overwrite_directory].each do |bool|
+        if config[:link][bool]
+          boolelem = Etch.xmlnewelem(bool.to_s, doc)
+          linkelem << boolelem
+        end
+      end
+      if config[:link][:dest]
+        elem = Etch.xmlnewelem('dest', doc)
+        Etch.xmlsettext(elem, config[:link][:dest])
+        linkelem << elem
+      end
+    end
+    if config[:directory]
+      direlem = Etch.xmlnewelem('directory', doc)
+      root << direlem
+      [:owner, :group, :perms].each do |text|
+        if config[:directory][text]
+          textelem = Etch.xmlnewelem(text.to_s, doc)
+          Etch.xmlsettext(textelem, config[:directory][text])
+          direlem << textelem
+        end
+      end
+      [:create].each do |bool|
+        if config[:directory][bool]
+          boolelem = Etch.xmlnewelem(bool.to_s, doc)
+          direlem << boolelem
+        end
+      end
+    end
+    if config[:delete]
+      deleteelem = Etch.xmlnewelem('delete', doc)
+      root << deleteelem
+      [:overwrite_directory, :proceed].each do |bool|
+        if config[:delete][bool]
+          boolelem = Etch.xmlnewelem(bool.to_s, doc)
+          deleteelem << boolelem
+        end
+      end
+    end
+    if config[:test_before_post]
+      elem = Etch.xmlnewelem('test_before_post', doc)
+      config[:test_before_post].each do |exec|
+        execelem = Etch.xmlnewelem('exec', doc)
+        Etch.xmlsettext(execelem, exec)
+        elem << execelem
+      end
+      root << elem
+    end
+    postelem = nil
+    {
+      :post_once => :exec_once,
+      :post_once_per_run => :exec_once_per_run,
+      :post => :exec,
+        }.each do |posttype, xmltype|
+      if config[posttype]
+        if !postelem
+          postelem = Etch.xmlnewelem('post', doc)
+          root << postelem
+        end
+        config[posttype].each do |postexec|
+          execelem = Etch.xmlnewelem(xmltype.to_s, doc)
+          Etch.xmlsettext(execelem, postexec)
+          postelem << execelem
+        end
+      end
+    end
+    if config[:test]
+      elem = Etch.xmlnewelem('test', doc)
+      config[:test].each do |exec|
+        execelem = Etch.xmlnewelem('exec', doc)
+        Etch.xmlsettext(execelem, exec)
+        elem << execelem
+      end
+      root << elem
+    end
+    doc
+  end
+  def self.command_xml_to_hash(command_xml)
+    cmd = {}
+    Etch.xmleach(command_xml, '/commands/depend') do |depend|
+      cmd[:depend] ||= []
+      cmd[:depend] << Etch.xmltext(depend)
+    end
+    Etch.xmleach(command_xml, '/commands/dependfile') do |dependfile|
+      cmd[:dependfile] ||= []
+      cmd[:dependfile] << Etch.xmltext(dependfile)
+    end
+    Etch.xmleach(command_xml, '/commands/step') do |step_xml|
+      cmd[:steps] ||= []
+      step = {}
+      cmd[:steps] << {step: step}
+      Etch.xmleach(step_xml, 'guard/exec') do |gexec|
+        step[:guard] ||= []
+        step[:guard] << Etch.xmltext(gexec)
+      end
+      Etch.xmleach(step_xml, 'command/exec') do |cexec|
+        step[:command] ||= []
+        step[:command] << Etch.xmltext(cexec)
+      end
+    end
+    cmd
+  end
+  def self.command_hash_to_xml(cmd, commandname)
+    doc = Etch.xmlnewdoc
+    root = Etch.xmlnewelem('commands', doc)
+    Etch.xmlattradd(root, 'commandname', commandname)
+    Etch.xmlsetroot(doc, root)
+    if cmd[:depend]
+      cmd[:depend].each do |depend|
+        depelem = Etch.xmlnewelem('depend', doc)
+        Etch.xmlsettext(depelem, depend)
+        root << depelem
+      end
+    end
+    if cmd[:dependfile]
+      cmd[:dependfile].each do |dependfile|
+        depelem = Etch.xmlnewelem('dependfile', doc)
+        Etch.xmlsettext(depelem, dependfile)
+        root << depelem
+      end
+    end
+    if cmd[:steps]
+      cmd[:steps].each do |outerstep|
+        if step = outerstep[:step]
+          stepelem = Etch.xmlnewelem('step', doc)
+          guardelem = Etch.xmlnewelem('guard', doc)
+          step[:guard] && step[:guard].each do |exec|
+            execelem = Etch.xmlnewelem('exec', doc)
+            Etch.xmlsettext(execelem, exec)
+            guardelem << execelem
+          end
+          stepelem << guardelem
+          commandelem = Etch.xmlnewelem('command', doc)
+          step[:command] && step[:command].each do |exec|
+            execelem = Etch.xmlnewelem('exec', doc)
+            Etch.xmlsettext(execelem, exec)
+            commandelem << execelem
+          end
+          stepelem << commandelem
+          root << stepelem
+        end
+      end
+    end
+    doc
+  end
+
   # We let users specify a source multiple times in a config.xml.  This is
   # necessary if multiple groups require the same file, for example.
   # However, the user needs to be consistent.  So this is valid on a
@@ -1109,12 +1620,7 @@ class Etch
   # This subroutine checks a list of XML elements to determine if they all
   # contain the same value.  Returns true if there is inconsistency.
   def check_for_inconsistency(elements)
-    elements_as_text = elements.collect { |elem| Etch.xmltext(elem) }
-    if elements_as_text.uniq.length > 1
-      return true
-    else
-      return false
-    end
+    elements.any?{|e| e != elements.first}
   end
   
   # These methods provide an abstraction from the underlying XML library in
@@ -1160,6 +1666,24 @@ class Etch
     end
   end
   
+  def self.xmlloadstr(string)
+    case Etch.xmllib
+    when :libxml
+      LibXML::XML::Document.string(string)
+    when :nokogiri
+      Nokogiri::XML(string) do |config|
+        # Nokogiri is tolerant of malformed documents by default.  Good when
+        # parsing HTML, but there's no reason for us to tolerate errors.  We
+        # want to ensure that the user's instructions to us are clear.
+        config.options = Nokogiri::XML::ParseOptions::STRICT
+      end
+    when :rexml
+      REXML::Document.new(string)
+    else
+      raise "Unknown XML library #{Etch.xmllib}"
+    end
+  end
+  
   def self.xmlload(file)
     case Etch.xmllib
     when :libxml
@@ -1476,6 +2000,9 @@ class Etch
 end
 
 class EtchExternalSource
+  # Save the original $LOAD_PATH ($:) to be restored later.
+  @@load_path_org = $LOAD_PATH.clone
+
   def initialize(file, original_file, facts, groups, local_requests, sourcebase, commandsbase, sitelibbase, dlogger)
     # The external source is going to be processed within the same Ruby
     # instance as etch.  We want to make it clear what variables we are
@@ -1485,7 +2012,15 @@ class EtchExternalSource
     @original_file = original_file
     @facts = facts
     @groups = groups
-    @local_requests = local_requests
+    # In the olden days all local requests were XML snippits that the etch client
+    # smashed into a single XML document to send over the wire.  This supports
+    # scripts expecting the old interface.
+    @local_requests = nil
+    if local_requests
+      @local_requests = "<requests>\n#{local_requests.join('')}\n</requests>"
+    end
+    # And this is a new interface where we just pass them as an array
+    @local_requests_array = local_requests || []
     @sourcebase = sourcebase
     @commandsbase = commandsbase
     @sitelibbase = sitelibbase
@@ -1509,6 +2044,8 @@ class EtchExternalSource
       # Help the user figure out where the exception occurred, otherwise they
       # just get told it happened here, which isn't very helpful.
       raise Etch.wrap_exception(e, "Exception while processing template #{template} for file #{@file}:\n" + e.message)
+    ensure
+      restore_globals
     end
   end
 
@@ -1529,9 +2066,32 @@ class EtchExternalSource
         # just get told it happened here in eval, which isn't very helpful.
         raise Etch.wrap_exception(e, "Exception while processing script #{script} for file #{@file}:\n" + e.message)
       end
+    ensure
+      restore_globals
     end
     @contents
   end
+
+  #
+  # Private subroutines
+  #
+  private
+
+  # Changes made to some global variables by the external sources can cause
+  # serious complications because they are executed repeatedly in a single
+  # worker process.
+  # We need to initialize them after each execution in order to make them
+  # "to act as much like a real script as possible".
+  def restore_globals
+    # Restore the original $LOAD_PATH to negate any changes made.
+    $LOAD_PATH.replace @@load_path_org
+    # Could restore the original $LOADED_FEATURES ($"), but this worker process
+    # acculumates many gems and modules over time and it's not practical to
+    # reload them every time.
+    # So, just deleting those in @sitelibbase or @sourcebase directory.
+    $LOADED_FEATURES.reject! {|x| x.start_with?(@sitelibbase, @sourcebase)}
+  end
+
   # The user might call return within a script.  We want the scripts to act as
   # much like a real script as possible.  Wrapping the eval in an extra method
   # allows us to handle a return within the script seamlessly.  If the user